@voidmob/mcp 0.1.0

package/dist/tools/orders.js

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import { state } from "../sandbox/state.js";
+import { formatUsd, formatGb, formatTimeRemaining } from "../utils/format.js";
+export function registerOrdersTools(server) {
+    server.tool("list_orders", "List all orders across SMS, eSIM, and proxy services. Filter by service type or status.", {
+        type: z
+            .enum(["sms", "esim", "proxy"])
+            .optional()
+            .describe("Filter by service type"),
+        status: z
+            .enum(["active", "completed", "cancelled", "expired", "all"])
+            .optional()
+            .describe("Filter by status (default: all)"),
+    }, async ({ type, status }) => {
+        const statusFilter = status ?? "all";
+        const orders = [];
+        if (!type || type === "sms") {
+            for (const rental of state.smsRentals.values()) {
+                if (statusFilter !== "all" && rental.status !== statusFilter)
+                    continue;
+                orders.push({
+                    type: "SMS",
+                    name: `${rental.service} (${rental.country}) — ${rental.number}`,
+                    id: rental.rentalId,
+                    status: rental.status,
+                    price: rental.price,
+                    details: `Messages: ${rental.messages.length}`,
+                    createdAt: rental.createdAt,
+                });
+            }
+        }
+        if (!type || type === "esim") {
+            for (const order of state.esimOrders.values()) {
+                if (statusFilter !== "all" && order.status !== statusFilter)
+                    continue;
+                const dataRemaining = formatGb(Math.max(0, order.dataTotal - order.dataUsed));
+                const timeLeft = formatTimeRemaining(order.expiry);
+                orders.push({
+                    type: "eSIM",
+                    name: `${order.planName} (${order.country})`,
+                    id: order.orderId,
+                    status: order.status,
+                    price: order.price,
+                    details: `Data remaining: ${dataRemaining} | ${timeLeft}`,
+                    createdAt: order.createdAt,
+                });
+            }
+        }
+        if (!type || type === "proxy") {
+            for (const proxy of state.proxies.values()) {
+                if (statusFilter !== "all" && proxy.status !== statusFilter)
+                    continue;
+                orders.push({
+                    type: "Proxy",
+                    name: `${proxy.type.toUpperCase()} proxy — ${proxy.country} (${proxy.carrier})`,
+                    id: proxy.proxyId,
+                    status: proxy.status,
+                    price: proxy.price,
+                    details: `Bandwidth: ${formatGb(proxy.bandwidthUsed)} / ${formatGb(proxy.bandwidthTotal)}`,
+                    createdAt: proxy.createdAt,
+                });
+            }
+        }
+        if (orders.length === 0) {
+            return {
+                content: [{ type: "text", text: "No orders found." }],
+            };
+        }
+        orders.sort((a, b) => b.createdAt - a.createdAt);
+        let text = `${orders.length} order(s):\n`;
+        for (const o of orders) {
+            const date = new Date(o.createdAt).toISOString().slice(0, 16).replace("T", " ");
+            text += `\n  [${o.type}] ${o.name}`;
+            text += `\n    ID: ${o.id}`;
+            text += `\n    Status: ${o.status}  |  Price: ${formatUsd(o.price)}`;
+            text += `\n    ${o.details}`;
+            text += `\n    Created: ${date}\n`;
+        }
+        return { content: [{ type: "text", text }] };
+    });
+}

package/dist/tools/proxy.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerProxyTools(server: McpServer): void;

package/dist/tools/proxy.js

@@ -0,0 +1,232 @@
+import { z } from "zod";
+import { state } from "../sandbox/state.js";
+import { validateCountry, ToolError, generateId } from "../utils/validation.js";
+import { formatUsd, formatGb, formatTimeRemaining, generateProxyCredentials, generateIp, } from "../utils/format.js";
+import { searchProxyOptions, getProxyPricing } from "../mock-data/proxy.js";
+function errorResponse(message) {
+    return {
+        content: [{ type: "text", text: message }],
+        isError: true,
+    };
+}
+export function registerProxyTools(server) {
+    server.tool("search_proxies", "Search available mobile proxy options. Filter by country or proxy type (gb = pay-per-GB, dedicated = fixed monthly).", {
+        country: z
+            .string()
+            .optional()
+            .describe("ISO 3166-1 alpha-2 country code (e.g., US, GB, DE)"),
+        type: z
+            .enum(["gb", "dedicated"])
+            .optional()
+            .describe("Proxy type: 'gb' for pay-per-GB or 'dedicated' for fixed monthly"),
+    }, async ({ country, type }) => {
+        try {
+            const validatedCountry = country ? validateCountry(country) : undefined;
+            const results = searchProxyOptions(validatedCountry, type);
+            if (results.length === 0) {
+                return errorResponse("No proxy options found matching your criteria. Try a different country or type.");
+            }
+            let text = `Found ${results.length} proxy option(s):\n\n`;
+            for (const p of results) {
+                text += `  ${p.carrier} — ${p.country} (${p.type})\n`;
+                text += `    Network: ${p.network}\n`;
+                if (p.type === "gb") {
+                    text += `    Price:   ${formatUsd(p.pricePerGb)}/GB\n`;
+                }
+                else {
+                    text += `    Price:   ${formatUsd(p.pricePerMonth)}/month\n`;
+                    text += `    Included bandwidth: ${formatGb(p.bandwidth)}\n`;
+                }
+                text += `\n`;
+            }
+            return { content: [{ type: "text", text }] };
+        }
+        catch (e) {
+            if (e instanceof ToolError)
+                return errorResponse(e.message);
+            throw e;
+        }
+    });
+    server.tool("get_proxy_pricing", "Get detailed pricing for a specific proxy type and country combination.", {
+        type: z
+            .enum(["gb", "dedicated"])
+            .describe("Proxy type: 'gb' for pay-per-GB or 'dedicated' for fixed monthly"),
+        country: z.string().describe("ISO 3166-1 alpha-2 country code (e.g., US, GB)"),
+    }, async ({ type, country }) => {
+        try {
+            const validatedCountry = validateCountry(country);
+            const options = getProxyPricing(type, validatedCountry);
+            if (options.length === 0) {
+                return errorResponse(`No ${type} proxies available in ${validatedCountry}. Use search_proxies to find available options.`);
+            }
+            let text = `${type === "gb" ? "Pay-per-GB" : "Dedicated"} proxy pricing — ${validatedCountry}:\n\n`;
+            for (const opt of options) {
+                text += `  ${opt.carrier} (${opt.network})\n`;
+                if (opt.type === "gb") {
+                    text += `    Rate: ${formatUsd(opt.pricePerGb)}/GB\n`;
+                }
+                else {
+                    text += `    Rate:      ${formatUsd(opt.pricePerMonth)}/month\n`;
+                    text += `    Bandwidth: ${formatGb(opt.bandwidth)} included\n`;
+                }
+                text += `\n`;
+            }
+            return { content: [{ type: "text", text }] };
+        }
+        catch (e) {
+            if (e instanceof ToolError)
+                return errorResponse(e.message);
+            throw e;
+        }
+    });
+    server.tool("purchase_proxy", "Purchase a mobile proxy. For GB type, quantity = GB to buy. For dedicated, quantity = months. Deducts cost from wallet.", {
+        type: z
+            .enum(["gb", "dedicated"])
+            .describe("Proxy type: 'gb' for pay-per-GB or 'dedicated' for fixed monthly"),
+        country: z.string().describe("ISO 3166-1 alpha-2 country code (e.g., US, GB)"),
+        quantity: z
+            .number()
+            .positive()
+            .optional()
+            .describe("GB for 'gb' type, months for 'dedicated' type (default: 1)"),
+    }, async ({ type, country, quantity }) => {
+        try {
+            const validatedCountry = validateCountry(country);
+            const qty = quantity ?? 1;
+            const options = getProxyPricing(type, validatedCountry);
+            if (options.length === 0) {
+                return errorResponse(`No ${type} proxies available in ${validatedCountry}. Use search_proxies to find available options.`);
+            }
+            // Pick the first carrier option
+            const option = options[0];
+            let totalCost;
+            let bandwidthTotal;
+            let expiryMs;
+            const now = Date.now();
+            if (option.type === "gb") {
+                totalCost = Math.round(qty * option.pricePerGb * 100) / 100;
+                bandwidthTotal = qty;
+                expiryMs = now + 30 * 24 * 60 * 60 * 1000; // 30 days
+            }
+            else {
+                totalCost = Math.round(qty * option.pricePerMonth * 100) / 100;
+                bandwidthTotal = option.bandwidth;
+                expiryMs = now + qty * 30 * 24 * 60 * 60 * 1000; // quantity * 30 days
+            }
+            if (!state.deductBalance(totalCost, "proxy_purchase", `Proxy: ${type} ${option.carrier} (${validatedCountry})`)) {
+                return errorResponse(`Insufficient balance. Need ${formatUsd(totalCost)} but have ${formatUsd(state.balance)}. Use deposit to add funds.`);
+            }
+            const proxyId = generateId("prx");
+            const credentials = generateProxyCredentials(validatedCountry);
+            const ip = generateIp();
+            state.proxies.set(proxyId, {
+                proxyId,
+                type,
+                country: validatedCountry,
+                carrier: option.carrier,
+                credentials,
+                bandwidthUsed: 0,
+                bandwidthTotal,
+                status: "active",
+                ip,
+                createdAt: now,
+                price: totalCost,
+            });
+            const connectionString = `${credentials.host}:${credentials.port}:${credentials.username}:${credentials.password}`;
+            const text = [
+                `Proxy purchased!`,
+                ``,
+                `  Proxy ID:    ${proxyId}`,
+                `  Type:        ${type === "gb" ? "Pay-per-GB" : "Dedicated"}`,
+                `  Carrier:     ${option.carrier} (${option.network})`,
+                `  Country:     ${validatedCountry}`,
+                `  Cost:        ${formatUsd(totalCost)}`,
+                `  Bandwidth:   ${formatGb(bandwidthTotal)}`,
+                `  Expires:     ${formatTimeRemaining(expiryMs)}`,
+                ``,
+                `  Connection:`,
+                `    Host:      ${credentials.host}`,
+                `    Port:      ${credentials.port}`,
+                `    Username:  ${credentials.username}`,
+                `    Password:  ${credentials.password}`,
+                `    String:    ${connectionString}`,
+                `    Current IP: ${ip}`,
+                ``,
+                `Use get_proxy_status to check bandwidth usage, or rotate_proxy to get a new IP.`,
+            ].join("\n");
+            return { content: [{ type: "text", text }] };
+        }
+        catch (e) {
+            if (e instanceof ToolError)
+                return errorResponse(e.message);
+            throw e;
+        }
+    });
+    server.tool("get_proxy_status", "Check status, bandwidth usage, and connection details for a proxy.", {
+        proxyId: z.string().describe("Proxy ID returned from purchase_proxy"),
+    }, async ({ proxyId }) => {
+        try {
+            const proxy = state.proxies.get(proxyId);
+            if (!proxy) {
+                return errorResponse(`Proxy not found: ${proxyId}`);
+            }
+            const now = Date.now();
+            // Simulate bandwidth usage: ~0.05 GB/hour elapsed, cap at 90% of total
+            const hoursElapsed = (now - proxy.createdAt) / 3600000;
+            const simulatedUsage = hoursElapsed * 0.05;
+            const maxUsage = proxy.bandwidthTotal * 0.9;
+            proxy.bandwidthUsed = Math.round(Math.min(simulatedUsage, maxUsage) * 100) / 100;
+            const bandwidthRemaining = Math.max(0, proxy.bandwidthTotal - proxy.bandwidthUsed);
+            const uptimeHours = Math.floor(hoursElapsed);
+            const uptimeMinutes = Math.floor((hoursElapsed - uptimeHours) * 60);
+            const text = [
+                `Proxy Status — ${proxy.carrier} (${proxy.country})`,
+                ``,
+                `  Proxy ID:           ${proxy.proxyId}`,
+                `  Status:             ${proxy.status}`,
+                `  Type:               ${proxy.type === "gb" ? "Pay-per-GB" : "Dedicated"}`,
+                `  Location:           ${proxy.country}`,
+                `  Current IP:         ${proxy.ip}`,
+                `  Bandwidth used:     ${formatGb(proxy.bandwidthUsed)}`,
+                `  Bandwidth remaining: ${formatGb(bandwidthRemaining)}`,
+                `  Bandwidth total:    ${formatGb(proxy.bandwidthTotal)}`,
+                `  Uptime:             ${uptimeHours}h ${uptimeMinutes}m`,
+            ].join("\n");
+            return { content: [{ type: "text", text }] };
+        }
+        catch (e) {
+            if (e instanceof ToolError)
+                return errorResponse(e.message);
+            throw e;
+        }
+    });
+    server.tool("rotate_proxy", "Rotate a proxy to get a new IP address. Only works on active proxies.", {
+        proxyId: z.string().describe("Proxy ID to rotate"),
+    }, async ({ proxyId }) => {
+        try {
+            const proxy = state.proxies.get(proxyId);
+            if (!proxy) {
+                return errorResponse(`Proxy not found: ${proxyId}`);
+            }
+            if (proxy.status !== "active") {
+                return errorResponse(`Proxy ${proxyId} is ${proxy.status}. Only active proxies can be rotated.`);
+            }
+            const oldIp = proxy.ip;
+            const newIp = generateIp();
+            proxy.ip = newIp;
+            const text = [
+                `IP rotated!`,
+                ``,
+                `  Proxy ID: ${proxy.proxyId}`,
+                `  Old IP:   ${oldIp}`,
+                `  New IP:   ${newIp}`,
+            ].join("\n");
+            return { content: [{ type: "text", text }] };
+        }
+        catch (e) {
+            if (e instanceof ToolError)
+                return errorResponse(e.message);
+            throw e;
+        }
+    });
+}

package/dist/tools/sms.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerSmsTools(server: McpServer): void;

package/dist/tools/sms.js

@@ -0,0 +1,158 @@
+import { z } from "zod";
+import { state } from "../sandbox/state.js";
+import { generateId } from "../utils/validation.js";
+import { formatUsd, generatePhoneNumber, generateVerificationCode, formatTimeRemaining, } from "../utils/format.js";
+import { searchServices, getServicePrice } from "../mock-data/sms.js";
+function errorResponse(message) {
+    return {
+        content: [{ type: "text", text: message }],
+        isError: true,
+    };
+}
+export function registerSmsTools(server) {
+    server.tool("search_sms_services", "Search available US non-VoIP SMS verification services. Filter by name or category.", {
+        query: z
+            .string()
+            .optional()
+            .describe("Search by service name or category (e.g., 'telegram', 'social')"),
+    }, async ({ query }) => {
+        const results = searchServices(query);
+        if (results.length === 0) {
+            return errorResponse("No services found matching your criteria. Try a different search term.");
+        }
+        let text = `Found ${results.length} US non-VoIP SMS service(s):\n\n`;
+        for (const s of results) {
+            text += `  ${s.name} (${s.id})\n`;
+            text += `    Category: ${s.category}\n`;
+            text += `    Country:  US (non-VoIP)\n`;
+            text += `    Price:    ${formatUsd(s.price)}\n`;
+            text += `    Delivery: ${s.estimatedDelivery}\n\n`;
+        }
+        return { content: [{ type: "text", text }] };
+    });
+    server.tool("get_sms_price", "Get pricing for a US non-VoIP SMS verification service.", {
+        service: z.string().describe("Service ID (e.g., 'whatsapp', 'telegram')"),
+    }, async ({ service }) => {
+        const result = getServicePrice(service);
+        if (!result) {
+            return errorResponse(`Service "${service}" not found. Use search_sms_services to find available options.`);
+        }
+        const text = [
+            `${result.service.name} — US (non-VoIP)`,
+            ``,
+            `  Price:    ${formatUsd(result.price)}`,
+            `  Delivery: ${result.service.estimatedDelivery}`,
+        ].join("\n");
+        return { content: [{ type: "text", text }] };
+    });
+    server.tool("rent_number", "Rent a US non-VoIP phone number to receive an SMS verification code. Deducts cost from wallet. Number expires in 5 minutes.", {
+        service: z.string().describe("Service ID (e.g., 'whatsapp', 'telegram')"),
+    }, async ({ service }) => {
+        const result = getServicePrice(service);
+        if (!result) {
+            return errorResponse(`Service "${service}" not found. Use search_sms_services to find available options.`);
+        }
+        const { price } = result;
+        if (!state.deductBalance(price, "sms_rental", `SMS rental: ${result.service.name} (US)`)) {
+            return errorResponse(`Insufficient balance. Need ${formatUsd(price)} but have ${formatUsd(state.balance)}. Use deposit to add funds.`);
+        }
+        const rentalId = generateId("sms");
+        const number = generatePhoneNumber("US");
+        const now = Date.now();
+        state.smsRentals.set(rentalId, {
+            rentalId,
+            number,
+            service,
+            country: "US",
+            status: "active",
+            messages: [],
+            expiry: now + 5 * 60 * 1000,
+            createdAt: now,
+            price,
+        });
+        const text = [
+            `Number rented!`,
+            ``,
+            `  Rental ID: ${rentalId}`,
+            `  Number:    ${number}`,
+            `  Service:   ${result.service.name}`,
+            `  Country:   US (non-VoIP)`,
+            `  Cost:      ${formatUsd(price)}`,
+            `  Expires:   ${formatTimeRemaining(now + 5 * 60 * 1000)}`,
+            ``,
+            `Use get_messages with the rental ID to check for incoming verification codes.`,
+        ].join("\n");
+        return { content: [{ type: "text", text }] };
+    });
+    server.tool("get_messages", "Check for incoming SMS messages on a rented number. Messages typically arrive within a few seconds.", {
+        rentalId: z.string().describe("Rental ID returned from rent_number"),
+    }, async ({ rentalId }) => {
+        const rental = state.smsRentals.get(rentalId);
+        if (!rental) {
+            return errorResponse(`Rental not found: ${rentalId}`);
+        }
+        if (rental.status === "active" && Date.now() >= rental.expiry) {
+            rental.status = "expired";
+        }
+        if (rental.status === "expired") {
+            return errorResponse(`Rental ${rentalId} has expired.`);
+        }
+        if (rental.status === "cancelled") {
+            return errorResponse(`Rental ${rentalId} has been cancelled.`);
+        }
+        // Lazy mock: generate a message after 5 seconds
+        if (rental.messages.length === 0) {
+            const elapsed = Date.now() - rental.createdAt;
+            if (elapsed < 5000) {
+                const text = [
+                    `No messages yet for ${rental.number} (${rental.service}).`,
+                    ``,
+                    `Waiting for verification code... try again shortly.`,
+                    `Time since rental: ${Math.floor(elapsed / 1000)}s`,
+                ].join("\n");
+                return { content: [{ type: "text", text }] };
+            }
+            const code = generateVerificationCode();
+            rental.messages.push({
+                from: rental.service,
+                text: `Your ${rental.service} verification code is: ${code}`,
+                receivedAt: Date.now(),
+            });
+        }
+        let text = `Messages for ${rental.number} (${rental.service}):\n\n`;
+        for (const msg of rental.messages) {
+            const time = new Date(msg.receivedAt).toISOString().slice(11, 19);
+            text += `  [${time}] From: ${msg.from}\n`;
+            text += `  ${msg.text}\n\n`;
+        }
+        return { content: [{ type: "text", text }] };
+    });
+    server.tool("cancel_rental", "Cancel an SMS rental. Refunds the full price only if no messages were received.", {
+        rentalId: z.string().describe("Rental ID to cancel"),
+    }, async ({ rentalId }) => {
+        const rental = state.smsRentals.get(rentalId);
+        if (!rental) {
+            return errorResponse(`Rental not found: ${rentalId}`);
+        }
+        if (rental.status !== "active") {
+            return errorResponse(`Rental ${rentalId} is ${rental.status} and cannot be cancelled.`);
+        }
+        rental.status = "cancelled";
+        if (rental.messages.length === 0) {
+            state.addBalance(rental.price, "refund", `Refund: ${rental.service} rental (US)`);
+            const text = [
+                `Rental ${rentalId} cancelled.`,
+                ``,
+                `  Refund: ${formatUsd(rental.price)} (no messages received)`,
+                `  New balance: ${formatUsd(state.balance)}`,
+            ].join("\n");
+            return { content: [{ type: "text", text }] };
+        }
+        const text = [
+            `Rental ${rentalId} cancelled.`,
+            ``,
+            `  No refund — messages were already received.`,
+        ].join("\n");
+        return { content: [{ type: "text", text }] };
+    });
+}

package/dist/tools/wallet.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerWalletTools(server: McpServer): void;

package/dist/tools/wallet.js

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { state } from "../sandbox/state.js";
+import { generateId } from "../utils/validation.js";
+import { formatUsd } from "../utils/format.js";
+export function registerWalletTools(server) {
+    server.tool("get_balance", "Get wallet balance and recent transactions. Resolves any pending deposits first.", {}, async () => {
+        state.resolvePendingDeposits();
+        const recent = state.transactions
+            .slice()
+            .sort((a, b) => b.createdAt - a.createdAt)
+            .slice(0, 10);
+        const pendingDeposits = [...state.deposits.values()].filter((d) => d.status === "pending");
+        let text = `Balance: ${formatUsd(state.balance)}\n`;
+        if (pendingDeposits.length > 0) {
+            text += `\nPending deposits: ${pendingDeposits.length}\n`;
+            for (const d of pendingDeposits) {
+                text += `  - ${formatUsd(d.amount)} ${d.currency} (auto-confirms in ~5s)\n`;
+            }
+        }
+        if (recent.length > 0) {
+            text += `\nLast ${recent.length} transactions:\n`;
+            for (const tx of recent) {
+                const sign = tx.amount >= 0 ? "+" : "";
+                const date = new Date(tx.createdAt).toISOString().slice(0, 16);
+                text += `  ${date}  ${sign}${formatUsd(Math.abs(tx.amount))}  ${tx.description}\n`;
+            }
+        }
+        else {
+            text += "\nNo transactions yet.\n";
+        }
+        return {
+            content: [{ type: "text", text }],
+        };
+    });
+    server.tool("deposit", "Create a crypto deposit to add funds to the wallet. Returns a mock payment link that auto-confirms in ~5 seconds.", {
+        amount: z.number().positive().describe("Amount in USD to deposit"),
+        currency: z
+            .enum(["BTC", "ETH", "SOL"])
+            .default("BTC")
+            .describe("Cryptocurrency to pay with (default: BTC)"),
+    }, async ({ amount, currency }) => {
+        const invoiceId = generateId("inv");
+        state.deposits.set(invoiceId, {
+            invoiceId,
+            amount,
+            currency,
+            status: "pending",
+            createdAt: Date.now(),
+        });
+        const payUrl = `https://sandbox.voidmob.com/pay/${invoiceId}`;
+        const text = [
+            `Deposit created!`,
+            ``,
+            `  Amount:   ${formatUsd(amount)}`,
+            `  Currency: ${currency}`,
+            `  Invoice:  ${invoiceId}`,
+            `  Pay URL:  ${payUrl}`,
+            ``,
+            `This is a sandbox deposit. It will auto-confirm in ~5 seconds.`,
+            `Call get_balance after a few seconds to see the updated balance.`,
+        ].join("\n");
+        return {
+            content: [{ type: "text", text }],
+        };
+    });
+}

package/dist/utils/format.d.ts

@@ -0,0 +1,12 @@
+export declare function formatUsd(amount: number): string;
+export declare function formatGb(gb: number): string;
+export declare function formatTimeRemaining(expiryMs: number): string;
+export declare function generatePhoneNumber(country: string): string;
+export declare function generateProxyCredentials(country: string): {
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+};
+export declare function generateIp(): string;
+export declare function generateVerificationCode(): string;

package/dist/utils/format.js

@@ -0,0 +1,55 @@
+export function formatUsd(amount) {
+    return `$${amount.toFixed(2)}`;
+}
+export function formatGb(gb) {
+    if (gb < 1)
+        return `${(gb * 1024).toFixed(0)} MB`;
+    return `${gb.toFixed(1)} GB`;
+}
+export function formatTimeRemaining(expiryMs) {
+    const remaining = expiryMs - Date.now();
+    if (remaining <= 0)
+        return "expired";
+    const hours = Math.floor(remaining / 3600000);
+    const minutes = Math.floor((remaining % 3600000) / 60000);
+    if (hours > 24)
+        return `${Math.floor(hours / 24)}d ${hours % 24}h`;
+    if (hours > 0)
+        return `${hours}h ${minutes}m`;
+    return `${minutes}m`;
+}
+export function generatePhoneNumber(country) {
+    const formats = {
+        US: () => `+1${rand(200, 999)}${rand(200, 999)}${rand(1000, 9999)}`,
+        GB: () => `+447${rand(100, 999)}${rand(100000, 999999)}`,
+        CA: () => `+1${rand(200, 999)}${rand(200, 999)}${rand(1000, 9999)}`,
+        DE: () => `+491${rand(50, 79)}${rand(1000000, 9999999)}`,
+        FR: () => `+336${rand(10000000, 99999999)}`,
+        NL: () => `+316${rand(10000000, 99999999)}`,
+        BR: () => `+5511${rand(90000, 99999)}${rand(1000, 9999)}`,
+        JP: () => `+8190${rand(1000, 9999)}${rand(1000, 9999)}`,
+        AU: () => `+614${rand(10, 99)}${rand(100000, 999999)}`,
+        IN: () => `+91${rand(70000, 99999)}${rand(10000, 99999)}`,
+    };
+    const gen = formats[country] || (() => `+${rand(1, 99)}${rand(100000000, 999999999)}`);
+    return gen();
+}
+function rand(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+export function generateProxyCredentials(country) {
+    const r = () => Math.random().toString(36).substring(2, 8);
+    return {
+        host: `${country.toLowerCase()}.proxy.voidmob.com`,
+        port: 10000 + Math.floor(Math.random() * 5000),
+        username: `vm_${r()}`,
+        password: r() + r(),
+    };
+}
+export function generateIp() {
+    const o = () => Math.floor(Math.random() * 254) + 1;
+    return `${o()}.${o()}.${o()}.${o()}`;
+}
+export function generateVerificationCode() {
+    return Math.floor(100000 + Math.random() * 900000).toString();
+}

package/dist/utils/validation.d.ts

@@ -0,0 +1,6 @@
+export declare function validateCountry(country: string): string;
+export declare function requireField(value: unknown, fieldName: string): void;
+export declare class ToolError extends Error {
+    constructor(message: string);
+}
+export declare function generateId(prefix: string): string;

package/dist/utils/validation.js

@@ -0,0 +1,32 @@
+// ISO 3166-1 alpha-2 country codes (subset of most common)
+const VALID_COUNTRIES = new Set([
+    "US", "GB", "CA", "AU", "DE", "FR", "NL", "IT", "ES", "PT",
+    "BR", "MX", "AR", "CO", "CL", "PE", "JP", "KR", "CN", "IN",
+    "ID", "TH", "VN", "PH", "MY", "SG", "HK", "TW", "RU", "UA",
+    "PL", "CZ", "RO", "SE", "NO", "DK", "FI", "AT", "CH", "BE",
+    "IE", "NZ", "ZA", "EG", "NG", "KE", "IL", "TR", "SA", "AE",
+]);
+export function validateCountry(country) {
+    const upper = country.toUpperCase();
+    if (!VALID_COUNTRIES.has(upper)) {
+        throw new ToolError(`Invalid country code: ${country}. Use ISO 3166-1 alpha-2 (e.g., US, GB, JP).`);
+    }
+    return upper;
+}
+export function requireField(value, fieldName) {
+    if (value === undefined || value === null || value === "") {
+        throw new ToolError(`Missing required field: ${fieldName}`);
+    }
+}
+export class ToolError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ToolError";
+    }
+}
+let counter = 0;
+export function generateId(prefix) {
+    counter++;
+    const rand = Math.random().toString(36).substring(2, 8);
+    return `${prefix}_${rand}${counter}`;
+}