lovieme 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,101 @@
-# 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 Developer CLI (`lovieme`)
+
+The official command-line interface for [LovieMe](https://www.lovie.me) — claim free `*.lovie.me` subdomains, manage global Anycast DNS records, and wire up 1-click cloud hosting presets directly from your terminal or CI/CD pipelines.
+
+---
+
+## ⚡ Zero Installation (Run with `npx`)
+
+```bash
+# Check subdomain availability
+npx lovieme subdomains check my-app
+
+# Run live multi-resolver DoH propagation check
+npx lovieme verify my-app
+```
+
+---
+
+## 📦 Global Installation
+
+```bash
+npm install -g lovieme
+```
+
+---
+
+## 🔑 Authentication
+
+Log in with your LovieMe API key (generate in [Dashboard > API Keys](https://www.lovie.me/dashboard/api-keys)):
+
+```bash
+# Save token locally to ~/.lovieme/config.json
+lovieme login lovie_live_your_token_here
+
+# Inspect your account and quotas
+lovieme whoami
+```
+
+Or set the environment variable:
+
+```bash
+export LOVIE_API_KEY="lovie_live_your_token_here"
+```
+
+---
+
+## 📖 Command Reference
+
+### Subdomains
+```bash
+# Check availability
+lovieme subdomains check <name>
+
+# Claim a subdomain
+lovieme subdomains claim <name>
+
+# List your claimed subdomains
+lovieme subdomains list
+
+# Delete/release a subdomain
+lovieme subdomains delete <name>
+```
+
+### Anycast DNS Records
+```bash
+# List records for a subdomain
+lovieme dns list <subdomain>
+
+# Add a CNAME record (points @ to Vercel)
+lovieme dns add <subdomain> --type CNAME --name @ --content cname.vercel-dns.com
+
+# Add an A record (points api to your VPS)
+lovieme dns add <subdomain> --type A --name api --content 192.0.2.1
+
+# Delete a record by ID
+lovieme dns rm <id>
+```
+
+### 1-Click Hosting Presets
+```bash
+# List all verified presets
+lovieme presets list
+
+# Apply Vercel preset
+lovieme presets apply <subdomain> vercel
+
+# Apply GitHub Pages preset
+lovieme presets apply <subdomain> github-pages --target username.github.io
+```
+
+### Global DoH Radar Verification
+```bash
+# Verify propagation worldwide (Google, Cloudflare, Quad9)
+lovieme verify <subdomain> --type CNAME
+```
+
+---
+
+## 📄 License
+MIT © Sagar Kewat (Sagarithm)
+

package/bin/lovieme.js

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

package/dist/client.d.ts

@@ -0,0 +1,104 @@
+export declare class CliClient {
+    private baseUrl;
+    private apiKey;
+    constructor();
+    private request;
+    checkSubdomain(name: string): Promise<{
+        available: boolean;
+        name: string;
+        fqdn: string;
+        reason?: string;
+    }>;
+    getProfile(): Promise<{
+        profile: {
+            id: string;
+            email?: string;
+            name?: string;
+            plan: string;
+            quota: {
+                subdomains_max: number;
+                subdomains_used: number;
+                subdomains_remaining: number;
+            };
+        };
+    }>;
+    listSubdomains(): Promise<{
+        subdomains: Array<{
+            id: string;
+            name: string;
+            fqdn: string;
+            created_at: string;
+            dns_records_count: number;
+            email_forwarder_active: boolean;
+        }>;
+    }>;
+    claimSubdomain(name: string): Promise<{
+        success: boolean;
+        message: string;
+        subdomain: {
+            id: string;
+            name: string;
+            fqdn: string;
+        };
+    }>;
+    deleteSubdomain(name: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    listDnsRecords(subdomain: string): Promise<{
+        dns_records: Array<{
+            id: string;
+            type: string;
+            name: string;
+            content: string;
+            ttl: number;
+            priority?: number;
+        }>;
+    }>;
+    addDnsRecord(data: {
+        subdomain: string;
+        type: string;
+        name: string;
+        content: string;
+        ttl?: number;
+        priority?: number;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        record: {
+            id: string;
+        };
+    }>;
+    removeDnsRecord(id: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    listPresets(): Promise<{
+        presets: Array<{
+            id: string;
+            name: string;
+            category?: string;
+            description: string;
+            requiresCustomInput?: boolean;
+            inputLabel?: string;
+            documentationUrl?: string;
+        }>;
+    }>;
+    applyPreset(subdomain: string, preset: string, customTarget?: string): Promise<{
+        success: boolean;
+        message: string;
+        created_records: Array<{
+            id: string;
+            name: string;
+            type: string;
+            content: string;
+        }>;
+    }>;
+    verifyDoH(domain: string, type?: string): Promise<{
+        resolver: string;
+        status: string;
+        latency: string;
+        targets: string;
+    }[]>;
+    private ensureAuth;
+}

package/dist/client.js

@@ -0,0 +1,127 @@
+import dns from "node:dns";
+import { getConfig } from "./config.js";
+try {
+    dns.setDefaultResultOrder?.("ipv4first");
+}
+catch {
+    // Ignore in environments where setDefaultResultOrder is unsupported
+}
+export class CliClient {
+    baseUrl;
+    apiKey;
+    constructor() {
+        const config = getConfig();
+        this.apiKey = config.apiKey || "";
+        this.baseUrl = (config.apiUrl || "https://www.lovie.me").replace(/\/+$/, "");
+    }
+    async request(path, options = {}) {
+        const url = `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+        const headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "LovieMe-CLI/0.1.1",
+            ...(options.headers || {}),
+        };
+        if (this.apiKey) {
+            headers["Authorization"] = `Bearer ${this.apiKey}`;
+        }
+        const res = await fetch(url, { ...options, headers });
+        const isJson = (res.headers.get("content-type") || "").includes("application/json");
+        const payload = isJson ? await res.json() : await res.text();
+        if (!res.ok) {
+            const msg = (typeof payload === "object" && payload !== null && (payload.error || payload.message)) ||
+                `HTTP ${res.status}: ${res.statusText}`;
+            throw new Error(String(msg));
+        }
+        return payload;
+    }
+    async checkSubdomain(name) {
+        const clean = name.replace(/\.lovie\.me$/i, "").trim().toLowerCase();
+        return this.request(`/api/v1/subdomains/check?name=${encodeURIComponent(clean)}`);
+    }
+    async getProfile() {
+        this.ensureAuth();
+        return this.request("/api/v1/me");
+    }
+    async listSubdomains() {
+        this.ensureAuth();
+        return this.request("/api/v1/subdomains");
+    }
+    async claimSubdomain(name) {
+        this.ensureAuth();
+        const clean = name.replace(/\.lovie\.me$/i, "").trim().toLowerCase();
+        return this.request("/api/v1/subdomains", { method: "POST", body: JSON.stringify({ name: clean }) });
+    }
+    async deleteSubdomain(name) {
+        this.ensureAuth();
+        const clean = name.replace(/\.lovie\.me$/i, "").trim().toLowerCase();
+        return this.request(`/api/v1/subdomains/${encodeURIComponent(clean)}`, {
+            method: "DELETE",
+        });
+    }
+    async listDnsRecords(subdomain) {
+        this.ensureAuth();
+        const clean = subdomain.replace(/\.lovie\.me$/i, "").trim().toLowerCase();
+        return this.request(`/api/v1/dns/records?subdomain=${encodeURIComponent(clean)}`);
+    }
+    async addDnsRecord(data) {
+        this.ensureAuth();
+        return this.request("/api/v1/dns/records", {
+            method: "POST",
+            body: JSON.stringify(data),
+        });
+    }
+    async removeDnsRecord(id) {
+        this.ensureAuth();
+        return this.request(`/api/v1/dns/records/${encodeURIComponent(id)}`, {
+            method: "DELETE",
+        });
+    }
+    async listPresets() {
+        return this.request("/api/v1/dns/presets");
+    }
+    async applyPreset(subdomain, preset, customTarget) {
+        this.ensureAuth();
+        return this.request("/api/v1/dns/presets", {
+            method: "POST",
+            body: JSON.stringify({ subdomain, preset, customTarget }),
+        });
+    }
+    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 settled = await Promise.allSettled(resolvers.map(async (r) => {
+            const start = Date.now();
+            const res = await fetch(r.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: r.name,
+                status: data.Answer && data.Answer.length > 0 ? "RESOLVED" : "NOT FOUND",
+                latency: `${latency}ms`,
+                targets: (data.Answer || []).map((a) => a.data).join(", ") || "-",
+            };
+        }));
+        return settled.map((s, i) => {
+            if (s.status === "fulfilled")
+                return s.value;
+            return {
+                resolver: resolvers[i].name,
+                status: "ERROR",
+                latency: "-",
+                targets: "-",
+            };
+        });
+    }
+    ensureAuth() {
+        if (!this.apiKey) {
+            throw new Error("Authentication required. Run `lovieme login <token>` or set LOVIE_API_KEY environment variable.");
+        }
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,7 @@
+export interface LovieMeConfig {
+    apiKey?: string;
+    apiUrl?: string;
+}
+export declare function getConfig(): LovieMeConfig;
+export declare function saveApiKey(key: string, url?: string): void;
+export declare function clearConfig(): void;

package/dist/config.js

@@ -0,0 +1,40 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+const CONFIG_DIR = path.join(os.homedir(), ".lovieme");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+export function getConfig() {
+    const envKey = process.env.LOVIE_API_KEY;
+    const envUrl = process.env.LOVIE_API_URL;
+    let fileConfig = {};
+    if (fs.existsSync(CONFIG_FILE)) {
+        try {
+            const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+            fileConfig = JSON.parse(raw);
+        }
+        catch {
+            // Ignore corrupted config
+        }
+    }
+    return {
+        apiKey: envKey || fileConfig.apiKey || "",
+        apiUrl: envUrl || fileConfig.apiUrl || "https://www.lovie.me",
+    };
+}
+export function saveApiKey(key, url) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    const existing = getConfig();
+    const nextConfig = {
+        ...existing,
+        apiKey: key.trim(),
+        apiUrl: url || existing.apiUrl || "https://www.lovie.me",
+    };
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(nextConfig, null, 2), "utf-8");
+}
+export function clearConfig() {
+    if (fs.existsSync(CONFIG_FILE)) {
+        fs.unlinkSync(CONFIG_FILE);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+import { CliClient } from "./client.js";
+export declare function createProgram(client?: CliClient): Command;
+export declare function main(): Promise<void>;

package/dist/index.js

@@ -0,0 +1,250 @@
+import { Command } from "commander";
+import { CliClient } from "./client.js";
+import { saveApiKey, clearConfig } from "./config.js";
+import { logSuccess, logInfo, logError, formatTable, colors } from "./ui.js";
+export function createProgram(client) {
+    const cli = client || new CliClient();
+    const program = new Command();
+    program
+        .name("lovieme")
+        .description("Official CLI for LovieMe — Developer & AI-Agent Custom Subdomains & Anycast DNS Cloud")
+        .version("0.1.1");
+    // 1. Auth: login / logout / whoami
+    program
+        .command("login")
+        .description("Log in to LovieMe using your personal or AI agent API key (lovie_live_...)")
+        .argument("<key>", "API key secret")
+        .action((key) => {
+        saveApiKey(key);
+        logSuccess("Saved API key to ~/.lovieme/config.json");
+    });
+    program
+        .command("logout")
+        .description("Remove stored credentials")
+        .action(() => {
+        clearConfig();
+        logSuccess("Logged out and purged ~/.lovieme/config.json");
+    });
+    program
+        .command("whoami")
+        .description("Show authenticated profile, plan tier, and subdomain quotas")
+        .action(async () => {
+        try {
+            const { profile } = await cli.getProfile();
+            console.log(`\n${colors.bold}LovieMe Account Profile${colors.reset}`);
+            console.log(`  User:     ${profile.name || profile.email || profile.id}`);
+            console.log(`  Plan:     ${colors.green}${profile.plan.toUpperCase()}${colors.reset}`);
+            console.log(`  Subdomains Used: ${profile.quota.subdomains_used} / ${profile.quota.subdomains_max}`);
+            console.log(`  Remaining:       ${profile.quota.subdomains_remaining}\n`);
+        }
+        catch (err) {
+            logError(err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+        }
+    });
+    // 2. Subdomains: check / claim / list / rm
+    const subdomains = program.command("subdomains").alias("sub").description("Manage custom *.lovie.me subdomains");
+    subdomains
+        .command("check <name>")
+        .description("Check availability of a subdomain prefix")
+        .action(async (name) => {
+        try {
+            const res = await cli.checkSubdomain(name);
+            if (res.available) {
+                logSuccess(`${colors.bold}${res.fqdn}${colors.reset} is AVAILABLE!`);
+            }
+            else {
+                logError(`${colors.bold}${res.fqdn}${colors.reset} is NOT available: ${res.reason || "already registered"}`);
+            }
+        }
+        catch (err) {
+            logError(err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+        }
+    });
+    subdomains
+        .command("claim <name>")
+        .description("Claim an available subdomain prefix under your account")
+        .action(async (name) => {
+        try {
+            const res = await cli.claimSubdomain(name);
+            logSuccess(`Subdomain claimed: ${colors.bold}${res.subdomain.fqdn}${colors.reset}`);
+        }
+        catch (err) {
+            logError(err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+        }
+    });
+    subdomains
+        .command("list")
+        .description("List all subdomains owned by your account")
+        .action(async () => {
+        try {
+            const { subdomains: list } = await cli.listSubdomains();
+            if (list.length === 0) {
+                logInfo("You have no claimed subdomains yet. Use `lovieme subdomains claim <name>`.");
+                return;
+            }
+            const headers = ["NAME", "FQDN", "DNS RECORDS", "FORWARDER", "CREATED AT"];
+            const rows = list.map((s) => [
+                s.name,
+                s.fqdn,
+                String(s.dns_records_count),
+                s.email_forwarder_active ? "Active" : "None",
+                new Date(s.created_at).toISOString().slice(0, 10),
+            ]);
+            console.log(`\n${formatTable(headers, rows)}\n`);
+        }
+        catch (err) {
+            logError(err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+        }
+    });
+    subdomains
+        .command("delete <name>")
+        .alias("rm")
+        .description("Release and permanently delete a subdomain")
+        .action(async (name) => {
+        try {
+            await cli.deleteSubdomain(name);
+            logSuccess(`Deleted subdomain: ${name}.lovie.me`);
+        }
+        catch (err) {
+            logError(err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+        }
+    });
+    // 3. DNS: list / add / rm
+    const dns = program.command("dns").description("Manage Gcore Anycast DNS records for your subdomains");
+    dns
+        .command("list <subdomain>")
+        .description("List all active DNS records for a subdomain")
+        .action(async (subdomain) => {
+        try {
+            const { dns_records: records } = await cli.listDnsRecords(subdomain);
+            if (records.length === 0) {
+                logInfo(`No DNS records found for ${subdomain}.lovie.me.`);
+                return;
+            }
+            const headers = ["ID", "TYPE", "NAME", "CONTENT", "TTL", "PRIORITY"];
+            const rows = records.map((r) => [
+                r.id.slice(0, 8),
+                r.type,
+                r.name,
+                r.content,
+                String(r.ttl),
+                r.priority !== undefined && r.priority !== null ? String(r.priority) : "-",
+            ]);
+            console.log(`\n${formatTable(headers, rows)}\n`);
+        }
+        catch (err) {
+            logError(err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+        }
+    });
+    dns
+        .command("add <subdomain>")
+        .description("Create a new DNS record on Anycast nameservers")
+        .requiredOption("-t, --type <type>", "Record type (A, AAAA, CNAME, TXT, MX)")
+        .requiredOption("-n, --name <name>", "Host label (@, www, api, etc.)")
+        .requiredOption("-c, --content <content>", "Target IP or host")
+        .option("--ttl <ttl>", "TTL in seconds", "300")
+        .option("-p, --priority <priority>", "Priority (required for MX)")
+        .action(async (subdomain, opts) => {
+        try {
+            await cli.addDnsRecord({
+                subdomain,
+                type: opts.type.toUpperCase(),
+                name: opts.name,
+                content: opts.content,
+                ttl: parseInt(opts.ttl, 10),
+                priority: opts.priority ? parseInt(opts.priority, 10) : undefined,
+            });
+            logSuccess(`Created ${opts.type.toUpperCase()} record on ${opts.name}.${subdomain}.lovie.me`);
+        }
+        catch (err) {
+            logError(err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+        }
+    });
+    dns
+        .command("rm <id>")
+        .description("Delete a DNS record by ID")
+        .action(async (id) => {
+        try {
+            await cli.removeDnsRecord(id);
+            logSuccess(`Deleted DNS record: ${id}`);
+        }
+        catch (err) {
+            logError(err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+        }
+    });
+    // 4. Presets
+    const presets = program.command("presets").description("1-Click Cloud Hosting Presets (Vercel, Railway, Render, etc.)");
+    presets
+        .command("list")
+        .description("List all verified cloud hosting presets")
+        .action(async () => {
+        try {
+            const { presets: list } = await cli.listPresets();
+            const headers = ["ID", "PLATFORM", "CATEGORY", "DESCRIPTION"];
+            const rows = list.map((p) => [
+                p.id,
+                p.name,
+                p.category || "cloud",
+                p.description,
+            ]);
+            console.log(`\n${formatTable(headers, rows)}\n`);
+        }
+        catch (err) {
+            logError(err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+        }
+    });
+    presets
+        .command("apply <subdomain> <preset>")
+        .description("Apply a cloud hosting preset to a subdomain")
+        .option("-t, --target <customTarget>", "Custom target value (e.g. GitHub username or Railway target)")
+        .action(async (subdomain, preset, opts) => {
+        try {
+            const res = await cli.applyPreset(subdomain, preset, opts.target);
+            logSuccess(res.message);
+            for (const r of res.created_records) {
+                console.log(`   + ${r.type} ${r.name} -> ${r.content}`);
+            }
+        }
+        catch (err) {
+            logError(err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+        }
+    });
+    // 5. Verify DoH
+    program
+        .command("verify <domain>")
+        .description("Verify live Anycast propagation across Google (8.8.8.8), Cloudflare (1.1.1.1), and Quad9 (9.9.9.9)")
+        .option("-t, --type <type>", "Record type to verify (A, CNAME, etc.)", "A")
+        .action(async (domain, opts) => {
+        try {
+            logInfo(`Verifying DoH propagation for ${domain} (${opts.type})...`);
+            const results = await cli.verifyDoH(domain, opts.type);
+            const headers = ["RESOLVER", "STATUS", "LATENCY", "RESOLVED TARGETS"];
+            const rows = results.map((r) => [
+                r.resolver,
+                r.status === "RESOLVED" ? `${colors.green}RESOLVED${colors.reset}` : `${colors.red}${r.status}${colors.reset}`,
+                r.latency,
+                r.targets,
+            ]);
+            console.log(`\n${formatTable(headers, rows)}\n`);
+        }
+        catch (err) {
+            logError(err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+        }
+    });
+    return program;
+}
+export async function main() {
+    const program = createProgram();
+    await program.parseAsync(process.argv);
+}

package/dist/ui.d.ts

@@ -0,0 +1,17 @@
+export declare const colors: {
+    reset: string;
+    bold: string;
+    dim: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    magenta: string;
+    cyan: string;
+    red: string;
+    white: string;
+};
+export declare function logSuccess(msg: string): void;
+export declare function logInfo(msg: string): void;
+export declare function logWarn(msg: string): void;
+export declare function logError(msg: string): void;
+export declare function formatTable(headers: string[], rows: string[][]): string;

package/dist/ui.js

@@ -0,0 +1,38 @@
+export const colors = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    red: "\x1b[31m",
+    white: "\x1b[37m",
+};
+export function logSuccess(msg) {
+    console.log(`${colors.green}✔${colors.reset} ${msg}`);
+}
+export function logInfo(msg) {
+    console.log(`${colors.cyan}ℹ${colors.reset} ${msg}`);
+}
+export function logWarn(msg) {
+    console.log(`${colors.yellow}⚠${colors.reset} ${msg}`);
+}
+export function logError(msg) {
+    console.error(`${colors.red}✖${colors.reset} ${msg}`);
+}
+export function formatTable(headers, rows) {
+    const colWidths = headers.map((h, i) => {
+        const maxRowLen = rows.reduce((max, row) => Math.max(max, (row[i] || "").length), 0);
+        return Math.max(h.length, maxRowLen);
+    });
+    const headerLine = headers.map((h, i) => h.padEnd(colWidths[i])).join("   ");
+    const separator = colWidths.map((w) => "─".repeat(w)).join("   ");
+    const rowLines = rows.map((row) => row.map((cell, i) => (cell || "").padEnd(colWidths[i])).join("   "));
+    return [
+        `${colors.bold}${headerLine}${colors.reset}`,
+        `${colors.dim}${separator}${colors.reset}`,
+        ...rowLines,
+    ].join("\n");
+}

package/package.json

@@ -1,6 +1,42 @@
-{
-  "name": "lovieme",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "lovieme",
+  "version": "0.1.1",
+  "description": "Official CLI for LovieMe — claim free *.lovie.me subdomains, configure Anycast DNS, and wire up cloud presets in seconds.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "lovieme": "bin/lovieme.js",
+    "lovie": "bin/lovieme.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "lovieme",
+    "cli",
+    "subdomain",
+    "dns",
+    "developer-tools",
+    "anycast",
+    "vercel",
+    "github-pages"
+  ],
+  "author": "Sagar Kewat (Sagarithm)",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.0",
+    "typescript": "^5.8.0",
+    "vitest": "^4.1.7"
+  }
+}