mcp-server-auction 0.2.0

package/build/index.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerTools } from "./tools.js";
+const server = new McpServer({
+    name: "server-auction",
+    version: "0.2.0",
+});
+registerTools(server);
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error("server-auction MCP server running on stdio");

package/build/providers/hetzner.js

@@ -0,0 +1,257 @@
+import { getCpuVendor } from "../utils.js";
+// ---------- Cache ----------
+const API_URL = "https://www.hetzner.com/_resources/app/data/app/live_data_sb_EUR.json";
+const CACHE_TTL_MS = 5 * 60 * 1000;
+let cache = null;
+async function fetchRawAuctions() {
+    if (cache && Date.now() - cache.timestamp < CACHE_TTL_MS) {
+        return cache.data;
+    }
+    const res = await fetch(API_URL);
+    if (!res.ok) {
+        throw new Error(`Hetzner API returned ${res.status}: ${res.statusText}`);
+    }
+    const json = (await res.json());
+    cache = { data: json.server, timestamp: Date.now() };
+    return json.server;
+}
+// ---------- Hetzner helpers ----------
+function hasGpu(server) {
+    return server.specials.some((s) => s.toUpperCase() === "GPU");
+}
+function getGpuModel(server) {
+    for (const desc of server.description) {
+        const match = desc.match(/GPU\s*-\s*(.+)/i);
+        if (match)
+            return match[1].trim();
+    }
+    return null;
+}
+function getDatacenterRegion(dc) {
+    const match = dc.match(/^([A-Z]+)/i);
+    return match ? match[1].toUpperCase() : dc;
+}
+function getCountry(dc) {
+    const region = getDatacenterRegion(dc);
+    if (region === "FSN" || region === "NBG")
+        return "DE";
+    if (region === "HEL")
+        return "FI";
+    return "DE";
+}
+function buildDisks(d) {
+    const disks = [];
+    const addGroup = (sizes, type) => {
+        const groups = new Map();
+        for (const size of sizes) {
+            groups.set(size, (groups.get(size) ?? 0) + 1);
+        }
+        for (const [size, count] of groups) {
+            disks.push({ count, size_gb: size, type });
+        }
+    };
+    addGroup(d.nvme, "nvme");
+    addGroup(d.sata, "sata");
+    addGroup(d.hdd, "hdd");
+    addGroup(d.general, "unknown");
+    return disks;
+}
+function normalizeServer(server, cores) {
+    const disks = buildDisks(server.serverDiskData);
+    return {
+        id: String(server.id),
+        provider: "hetzner",
+        url: `https://www.hetzner.com/sb?id=${server.id}`,
+        name: server.cpu,
+        cpu: server.cpu,
+        cpu_count: server.cpu_count,
+        cpu_cores: cores,
+        cpu_vendor: getCpuVendor(server.cpu),
+        ram_gb: server.ram_size,
+        is_ecc: server.is_ecc,
+        disks,
+        disk_total_gb: disks.reduce((sum, d) => sum + d.size_gb * d.count, 0),
+        disk_count: disks.reduce((sum, d) => sum + d.count, 0),
+        bandwidth_mbps: server.bandwidth,
+        datacenter: server.datacenter,
+        datacenter_region: getDatacenterRegion(server.datacenter),
+        country: getCountry(server.datacenter),
+        price_monthly_eur: server.price,
+        price_setup_eur: server.setup_price,
+        price_hourly_eur: server.hourly_price,
+        gpu: hasGpu(server),
+        gpu_model: getGpuModel(server),
+        is_highio: server.is_highio,
+        fixed_price: server.fixed_price,
+        next_reduce_timestamp: server.fixed_price
+            ? null
+            : server.next_reduce_timestamp,
+        availability: null,
+        specials: server.specials,
+    };
+}
+// ---------- CPU core resolution ----------
+// Hetzner doesn't include core counts in its API, so we resolve them
+// via a static lookup table + GitHub CSV fallback.
+const KNOWN_CORES = {
+    "AMD EPYC 7401P": 24,
+    "AMD EPYC 7502": 32,
+    "AMD EPYC 7502P": 32,
+    "AMD Ryzen 5 3600": 6,
+    "AMD Ryzen 7 1700X": 8,
+    "AMD Ryzen 7 3700X": 8,
+    "AMD Ryzen 7 7700": 8,
+    "AMD Ryzen 7 PRO 1700X": 8,
+    "AMD Ryzen 9 3900": 12,
+    "AMD Ryzen 9 5950X": 16,
+    "AMD Ryzen Threadripper 2950X": 16,
+    "Intel Core i5-12500": 6,
+    "Intel Core i7-6700": 4,
+    "Intel Core i7-7700": 4,
+    "Intel Core i7-8700": 6,
+    "Intel Core i9-9900K": 8,
+    "Intel Core i9-12900K": 16,
+    "Intel Core i9-13900": 24,
+    "Intel Xeon E3-1270V3": 4,
+    "Intel Xeon E3-1271V3": 4,
+    "Intel Xeon E3-1275v5": 4,
+    "Intel Xeon E3-1275V6": 4,
+    "Intel Xeon E5-1650V3": 6,
+    "Intel XEON E-2176G": 6,
+    "Intel XEON E-2276G": 6,
+    "Intel Xeon W-2145": 8,
+    "Intel Xeon W-2245": 8,
+    "Intel Xeon W-2295": 18,
+    "Intel Xeon Gold 5412U": 24,
+};
+function normaliseCpuName(name) {
+    return name
+        .replace(/[®™]/g, "")
+        .replace(/\s+/g, " ")
+        .trim()
+        .toLowerCase();
+}
+function extractModelToken(name) {
+    const cleaned = normaliseCpuName(name);
+    const m = cleaned.match(/(?:i[3579]-\d{4,5}[a-z]*|e[35]-\d{4}\s*v?\d*|e-\d{4}[a-z]*|w-\d{4,5}[a-z]*|gold \d{4}[a-z]*|epyc \d{4}[a-z]*|ryzen \d+ (?:pro )?\d{4}[a-z]*|threadripper \d{4,5}[a-z]*)/);
+    return m ? m[0] : null;
+}
+function parseCsvRow(line) {
+    const fields = [];
+    let current = "";
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (inQuotes) {
+            if (ch === '"') {
+                if (i + 1 < line.length && line[i + 1] === '"') {
+                    current += '"';
+                    i++;
+                }
+                else {
+                    inQuotes = false;
+                }
+            }
+            else {
+                current += ch;
+            }
+        }
+        else if (ch === '"') {
+            inQuotes = true;
+        }
+        else if (ch === ",") {
+            fields.push(current);
+            current = "";
+        }
+        else {
+            current += ch;
+        }
+    }
+    fields.push(current);
+    return fields;
+}
+const INTEL_CSV_URL = "https://raw.githubusercontent.com/felixsteinke/cpu-spec-dataset/main/dataset/intel-cpus.csv";
+const AMD_CSV_URL = "https://raw.githubusercontent.com/felixsteinke/cpu-spec-dataset/main/dataset/amd-cpus.csv";
+const CSV_CACHE_TTL_MS = 5 * 60 * 1000;
+let csvCache = null;
+async function fetchCsvCoreMap() {
+    if (csvCache && Date.now() - csvCache.timestamp < CSV_CACHE_TTL_MS) {
+        return csvCache.map;
+    }
+    const map = new Map();
+    try {
+        const [intelRes, amdRes] = await Promise.all([
+            fetch(INTEL_CSV_URL),
+            fetch(AMD_CSV_URL),
+        ]);
+        for (const { res, nameCol, coreCol } of [
+            { res: intelRes, nameCol: "CpuName", coreCol: "CoreCount" },
+            { res: amdRes, nameCol: "Model", coreCol: "# of CPU Cores" },
+        ]) {
+            if (!res.ok)
+                continue;
+            const text = await res.text();
+            const lines = text.split("\n");
+            const header = parseCsvRow(lines[0]);
+            const nameIdx = header.indexOf(nameCol);
+            const coreIdx = header.indexOf(coreCol);
+            if (nameIdx < 0 || coreIdx < 0)
+                continue;
+            for (let i = 1; i < lines.length; i++) {
+                if (!lines[i].trim())
+                    continue;
+                const row = parseCsvRow(lines[i]);
+                const cores = parseInt(row[coreIdx], 10);
+                if (!isNaN(cores) && row[nameIdx]) {
+                    const token = extractModelToken(row[nameIdx]);
+                    if (token && !map.has(token))
+                        map.set(token, cores);
+                }
+            }
+        }
+    }
+    catch {
+        // Network failure — return whatever we have.
+    }
+    csvCache = { map, timestamp: Date.now() };
+    return map;
+}
+async function resolveCpuCores(cpuName) {
+    if (cpuName in KNOWN_CORES)
+        return KNOWN_CORES[cpuName];
+    const norm = normaliseCpuName(cpuName);
+    for (const [key, cores] of Object.entries(KNOWN_CORES)) {
+        if (normaliseCpuName(key) === norm)
+            return cores;
+    }
+    const token = extractModelToken(cpuName);
+    if (token) {
+        const csvMap = await fetchCsvCoreMap();
+        const csvCores = csvMap.get(token);
+        if (csvCores !== undefined)
+            return csvCores;
+    }
+    return null;
+}
+async function resolveCpuCoresBulk(cpuNames) {
+    const unique = [...new Set(cpuNames)];
+    const result = new Map();
+    for (const name of unique) {
+        result.set(name, await resolveCpuCores(name));
+    }
+    return result;
+}
+// ---------- Provider ----------
+export const hetznerProvider = {
+    name: "hetzner",
+    displayName: "Hetzner",
+    async fetchListings() {
+        const servers = await fetchRawAuctions();
+        const coreMap = await resolveCpuCoresBulk(servers.map((s) => s.cpu));
+        return servers.map((s) => {
+            const perSocket = coreMap.get(s.cpu) ?? null;
+            const cores = perSocket !== null ? perSocket * s.cpu_count : null;
+            return normalizeServer(s, cores);
+        });
+    },
+};

package/build/providers/ovh.js

@@ -0,0 +1,202 @@
+import { getCpuVendor } from "../utils.js";
+// ---------- Cache ----------
+const CATALOG_URL = "https://eu.api.ovh.com/v1/order/catalog/public/eco?ovhSubsidiary=DE";
+const AVAILABILITY_URL = "https://eu.api.ovh.com/v1/dedicated/server/datacenter/availabilities";
+const CACHE_TTL_MS = 5 * 60 * 1000;
+let catalogCache = null;
+let availabilityCache = null;
+async function fetchCatalog() {
+    if (catalogCache && Date.now() - catalogCache.timestamp < CACHE_TTL_MS) {
+        return catalogCache.data;
+    }
+    const res = await fetch(CATALOG_URL);
+    if (!res.ok) {
+        throw new Error(`OVH Catalog API returned ${res.status}: ${res.statusText}`);
+    }
+    const data = (await res.json());
+    catalogCache = { data, timestamp: Date.now() };
+    return data;
+}
+async function fetchAvailability() {
+    if (availabilityCache &&
+        Date.now() - availabilityCache.timestamp < CACHE_TTL_MS) {
+        return availabilityCache.data;
+    }
+    const res = await fetch(AVAILABILITY_URL);
+    if (!res.ok) {
+        throw new Error(`OVH Availability API returned ${res.status}: ${res.statusText}`);
+    }
+    const data = (await res.json());
+    availabilityCache = { data, timestamp: Date.now() };
+    return data;
+}
+// ---------- DC mapping ----------
+const DC_COUNTRY = {
+    fra: "DE",
+    gra: "FR",
+    rbx: "FR",
+    sbg: "FR",
+    lon: "GB",
+    waw: "PL",
+    bhs: "CA",
+};
+function dcToCountry(dc) {
+    const prefix = dc.replace(/\d+$/, "").toLowerCase();
+    return DC_COUNTRY[prefix] ?? "FR";
+}
+function dcToRegion(dc) {
+    return dc.replace(/\d+$/, "").toUpperCase();
+}
+function parseMemoryCode(code) {
+    // e.g. "ram-32g-ecc-3200", "ram-64g-noecc-2400"
+    const match = code.match(/ram-(\d+)g/i);
+    if (!match)
+        return null;
+    return {
+        size_gb: parseInt(match[1], 10),
+        is_ecc: code.toLowerCase().includes("ecc") && !code.toLowerCase().includes("noecc"),
+    };
+}
+function parseStorageCode(code) {
+    // e.g. "softraid-2x512nvme", "softraid-2x2000sa", "softraid-4x960ssd"
+    // Also handle "raid" variants: "raid1-2x512nvme"
+    const match = code.match(/(\d+)x(\d+)(nvme|ssd|sa|hdd)/i);
+    if (!match)
+        return [];
+    const count = parseInt(match[1], 10);
+    const size = parseInt(match[2], 10);
+    const rawType = match[3].toLowerCase();
+    const type = rawType === "nvme" ? "nvme"
+        : rawType === "ssd" ? "sata"
+            : rawType === "sa" ? "hdd"
+                : rawType === "hdd" ? "hdd"
+                    : "unknown";
+    return [{ count, size_gb: size, type }];
+}
+// ---------- Price normalization ----------
+function extractMonthlyPrice(plan) {
+    // Look for monthly renew pricing
+    const renew = plan.pricings.find((p) => p.capacities.includes("renew") && (p.interval === 1 || p.interval === undefined));
+    if (!renew)
+        return 0;
+    // OVH catalog prices are in cents (hundredths of EUR)
+    const priceEur = renew.price / 100_000_000;
+    // Sanity check: if price seems too low after division, try cents
+    if (priceEur < 1 && renew.price > 100)
+        return renew.price / 100;
+    return priceEur;
+}
+function extractSetupPrice(plan) {
+    const install = plan.pricings.find((p) => p.capacities.includes("installation"));
+    if (!install)
+        return 0;
+    const priceEur = install.price / 100_000_000;
+    if (priceEur < 0.01 && install.price > 100)
+        return install.price / 100;
+    return priceEur;
+}
+// ---------- Normalization ----------
+function buildListing(entry, cpuInfo, pricing, planName, availableDcs) {
+    const mem = parseMemoryCode(entry.memory);
+    const disks = parseStorageCode(entry.storage);
+    const cpuName = cpuInfo
+        ? `${cpuInfo.brand ?? ""} ${cpuInfo.model ?? ""}`.trim()
+        : planName;
+    const cpuCores = cpuInfo?.cores ?? null;
+    const firstDc = availableDcs[0];
+    const dcList = availableDcs.map((d) => dcToRegion(d.datacenter));
+    const uniqueDcs = [...new Set(dcList)];
+    // Best availability (prefer "available" over time-based like "1H", "24H", etc.)
+    const bestAvail = availableDcs.find((d) => d.availability === "available")?.availability ??
+        availableDcs[0]?.availability ??
+        "unknown";
+    return {
+        id: entry.fqn,
+        provider: "ovh",
+        url: "https://eco.ovhcloud.com/en/",
+        name: planName,
+        cpu: cpuName,
+        cpu_count: 1,
+        cpu_cores: cpuCores,
+        cpu_vendor: getCpuVendor(cpuName),
+        ram_gb: mem?.size_gb ?? 0,
+        is_ecc: mem?.is_ecc ?? false,
+        disks,
+        disk_total_gb: disks.reduce((sum, d) => sum + d.size_gb * d.count, 0),
+        disk_count: disks.reduce((sum, d) => sum + d.count, 0),
+        bandwidth_mbps: 1000, // OVH ECO default: 1 Gbit
+        datacenter: uniqueDcs.join(", "),
+        datacenter_region: uniqueDcs[0] ?? "",
+        country: firstDc ? dcToCountry(firstDc.datacenter) : "FR",
+        price_monthly_eur: pricing.monthly,
+        price_setup_eur: pricing.setup,
+        price_hourly_eur: null,
+        gpu: entry.gpu !== undefined && entry.gpu !== null && entry.gpu !== "",
+        gpu_model: entry.gpu || null,
+        is_highio: false,
+        fixed_price: true,
+        next_reduce_timestamp: null,
+        availability: bestAvail,
+        specials: [],
+    };
+}
+// ---------- Provider ----------
+export const ovhProvider = {
+    name: "ovh",
+    displayName: "OVH",
+    async fetchListings() {
+        const [catalog, availability] = await Promise.all([
+            fetchCatalog(),
+            fetchAvailability(),
+        ]);
+        // Build CPU info lookup: planCode → CPU specs (from first matching product)
+        const cpuByPlan = new Map();
+        for (const product of catalog.products) {
+            const planCode = product.name.split(".")[0];
+            if (!cpuByPlan.has(planCode) &&
+                product.blobs?.technical?.server?.cpu) {
+                cpuByPlan.set(planCode, product.blobs.technical.server.cpu);
+            }
+        }
+        // Build pricing lookup: planCode → { monthly, setup }
+        const pricingByPlan = new Map();
+        for (const plan of catalog.plans) {
+            if (!pricingByPlan.has(plan.planCode)) {
+                pricingByPlan.set(plan.planCode, {
+                    monthly: extractMonthlyPrice(plan),
+                    setup: extractSetupPrice(plan),
+                    name: plan.invoiceName ?? plan.planCode,
+                });
+            }
+        }
+        // Group availability entries by FQN (deduplicate)
+        const byFqn = new Map();
+        for (const entry of availability) {
+            const availDcs = entry.datacenters.filter((d) => d.availability !== "unavailable");
+            if (availDcs.length === 0)
+                continue;
+            const existing = byFqn.get(entry.fqn);
+            if (existing) {
+                // Merge DCs
+                for (const dc of availDcs) {
+                    if (!existing.dcs.some((d) => d.datacenter === dc.datacenter)) {
+                        existing.dcs.push(dc);
+                    }
+                }
+            }
+            else {
+                byFqn.set(entry.fqn, { entry, dcs: availDcs });
+            }
+        }
+        // Build listings
+        const listings = [];
+        for (const { entry, dcs } of byFqn.values()) {
+            const cpuInfo = cpuByPlan.get(entry.planCode) ?? null;
+            const planInfo = pricingByPlan.get(entry.planCode);
+            if (!planInfo)
+                continue; // Skip entries without pricing info
+            listings.push(buildListing(entry, cpuInfo, { monthly: planInfo.monthly, setup: planInfo.setup }, planInfo.name, dcs));
+        }
+        return listings;
+    },
+};

package/build/providers/registry.js

@@ -0,0 +1,17 @@
+import { hetznerProvider } from "./hetzner.js";
+import { ovhProvider } from "./ovh.js";
+const providers = [hetznerProvider, ovhProvider];
+export function getProviderNames() {
+    return providers.map((p) => p.name);
+}
+export async function getAllListings(providerFilter) {
+    const selected = providerFilter && providerFilter !== "all"
+        ? providers.filter((p) => p.name === providerFilter)
+        : providers;
+    const results = await Promise.all(selected.map((p) => p.fetchListings().catch(() => [])));
+    return results.flat();
+}
+export async function getListingById(id, providerFilter) {
+    const listings = await getAllListings(providerFilter);
+    return listings.find((l) => l.id === id);
+}

package/build/tools.js

@@ -0,0 +1,349 @@
+import { z } from "zod";
+import { getDiskType, formatDiskSummary, formatBandwidth, formatNextReduce, } from "./utils.js";
+import { getAllListings, getListingById } from "./providers/registry.js";
+const providerEnum = z
+    .enum(["hetzner", "ovh", "all"])
+    .optional()
+    .describe("Provider filter: hetzner, ovh, or all (default: all)");
+export function registerTools(server) {
+    server.tool("search_auctions", "Search and filter dedicated server auction listings by price, RAM, disk, CPU, datacenter, GPU, bandwidth, and more", {
+        provider: providerEnum,
+        max_price: z.number().optional().describe("Maximum monthly price in EUR"),
+        min_ram: z.number().optional().describe("Minimum RAM in GB"),
+        min_disk_size: z
+            .number()
+            .optional()
+            .describe("Minimum total disk capacity in GB"),
+        min_disk_count: z
+            .number()
+            .optional()
+            .describe("Minimum number of disks"),
+        disk_type: z
+            .enum(["ssd", "nvme", "hdd", "any"])
+            .optional()
+            .describe("Filter by disk type (ssd matches both SATA SSD and NVMe)"),
+        cpu_vendor: z
+            .enum(["intel", "amd", "any"])
+            .optional()
+            .describe("CPU vendor filter"),
+        cpu_search: z
+            .string()
+            .optional()
+            .describe("Free-text search within CPU model name (e.g. 'EPYC 7502', 'Xeon E5', 'Ryzen 9')"),
+        min_cpu_count: z
+            .number()
+            .optional()
+            .describe("Minimum CPU/socket count"),
+        min_cores: z
+            .number()
+            .optional()
+            .describe("Minimum total CPU cores (resolved from model name, accounts for multi-socket)"),
+        ecc: z.boolean().optional().describe("Require ECC RAM"),
+        datacenter: z
+            .string()
+            .optional()
+            .describe("Datacenter filter (e.g. FSN, NBG, HEL, FRA, GRA, or FSN1-DC1)"),
+        gpu: z.boolean().optional().describe("Require GPU"),
+        min_bandwidth: z
+            .number()
+            .optional()
+            .describe("Minimum bandwidth in Mbit (e.g. 1000 = 1 Gbit)"),
+        fixed_price: z
+            .boolean()
+            .optional()
+            .describe("Filter by pricing type: true = fixed price only, false = auction only"),
+        max_setup_price: z
+            .number()
+            .optional()
+            .describe("Maximum setup price in EUR (use 0 for no setup fee)"),
+        highio: z
+            .boolean()
+            .optional()
+            .describe("Require high I/O hardware"),
+        sort_by: z
+            .enum(["price", "ram", "disk_size", "cpu", "cores"])
+            .optional()
+            .describe("Sort field (default: price)"),
+        limit: z
+            .number()
+            .min(1)
+            .max(50)
+            .optional()
+            .describe("Max results (default: 10)"),
+    }, async (params) => {
+        const listings = await getAllListings(params.provider);
+        let filtered = listings.filter((s) => {
+            if (params.max_price !== undefined &&
+                s.price_monthly_eur > params.max_price)
+                return false;
+            if (params.min_ram !== undefined && s.ram_gb < params.min_ram)
+                return false;
+            if (params.min_disk_size !== undefined &&
+                s.disk_total_gb < params.min_disk_size)
+                return false;
+            if (params.min_disk_count !== undefined &&
+                s.disk_count < params.min_disk_count)
+                return false;
+            if (params.disk_type !== undefined && params.disk_type !== "any") {
+                const dt = getDiskType(s);
+                if (params.disk_type === "ssd") {
+                    if (dt !== "nvme" && dt !== "sata")
+                        return false;
+                }
+                else if (params.disk_type === "nvme") {
+                    if (dt !== "nvme")
+                        return false;
+                }
+                else if (params.disk_type === "hdd") {
+                    if (dt !== "hdd")
+                        return false;
+                }
+            }
+            if (params.cpu_vendor !== undefined &&
+                params.cpu_vendor !== "any") {
+                if (s.cpu_vendor !== params.cpu_vendor)
+                    return false;
+            }
+            if (params.cpu_search !== undefined) {
+                if (!s.cpu.toLowerCase().includes(params.cpu_search.toLowerCase()))
+                    return false;
+            }
+            if (params.min_cpu_count !== undefined &&
+                s.cpu_count < params.min_cpu_count)
+                return false;
+            if (params.min_cores !== undefined) {
+                if (s.cpu_cores === null || s.cpu_cores < params.min_cores)
+                    return false;
+            }
+            if (params.ecc === true && !s.is_ecc)
+                return false;
+            if (params.datacenter !== undefined) {
+                const dcUpper = params.datacenter.toUpperCase();
+                // Support comma-separated datacenter lists (e.g. OVH multi-DC)
+                const dcs = s.datacenter
+                    .toUpperCase()
+                    .split(",")
+                    .map((d) => d.trim());
+                if (!dcs.some((d) => d.startsWith(dcUpper)))
+                    return false;
+            }
+            if (params.gpu === true && !s.gpu)
+                return false;
+            if (params.min_bandwidth !== undefined &&
+                s.bandwidth_mbps < params.min_bandwidth)
+                return false;
+            if (params.fixed_price !== undefined &&
+                s.fixed_price !== params.fixed_price)
+                return false;
+            if (params.max_setup_price !== undefined &&
+                s.price_setup_eur > params.max_setup_price)
+                return false;
+            if (params.highio === true && !s.is_highio)
+                return false;
+            return true;
+        });
+        const sortBy = params.sort_by ?? "price";
+        filtered.sort((a, b) => {
+            switch (sortBy) {
+                case "price":
+                    return a.price_monthly_eur - b.price_monthly_eur;
+                case "ram":
+                    return b.ram_gb - a.ram_gb;
+                case "disk_size":
+                    return b.disk_total_gb - a.disk_total_gb;
+                case "cpu":
+                    return b.cpu_count - a.cpu_count;
+                case "cores":
+                    return (b.cpu_cores ?? 0) - (a.cpu_cores ?? 0);
+                default:
+                    return a.price_monthly_eur - b.price_monthly_eur;
+            }
+        });
+        const limit = params.limit ?? 10;
+        const results = filtered.slice(0, limit);
+        if (results.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No servers found matching your criteria.",
+                    },
+                ],
+            };
+        }
+        const lines = [
+            `Found ${filtered.length} servers matching your criteria (showing top ${results.length}):\n`,
+        ];
+        for (let i = 0; i < results.length; i++) {
+            lines.push(formatServerLine(results[i], i + 1));
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    });
+    server.tool("get_auction_stats", "Get aggregate statistics about current server auction listings", {
+        provider: providerEnum,
+    }, async (params) => {
+        const listings = await getAllListings(params.provider);
+        const prices = listings
+            .map((s) => s.price_monthly_eur)
+            .sort((a, b) => a - b);
+        if (prices.length === 0) {
+            return {
+                content: [{ type: "text", text: "No listings available." }],
+            };
+        }
+        const avg = prices.reduce((a, b) => a + b, 0) / prices.length;
+        const median = prices.length % 2 === 0
+            ? (prices[prices.length / 2 - 1] + prices[prices.length / 2]) / 2
+            : prices[Math.floor(prices.length / 2)];
+        // Provider breakdown
+        const providerCounts = new Map();
+        for (const s of listings) {
+            providerCounts.set(s.provider, (providerCounts.get(s.provider) ?? 0) + 1);
+        }
+        const providerLines = [...providerCounts.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .map(([p, n]) => `  ${p.charAt(0).toUpperCase() + p.slice(1)}: ${n} servers`);
+        // CPU vendor breakdown
+        const intelListings = listings.filter((s) => s.cpu_vendor === "intel");
+        const amdListings = listings.filter((s) => s.cpu_vendor === "amd");
+        const intelAvg = intelListings.length > 0
+            ? intelListings.reduce((a, s) => a + s.price_monthly_eur, 0) /
+                intelListings.length
+            : 0;
+        const amdAvg = amdListings.length > 0
+            ? amdListings.reduce((a, s) => a + s.price_monthly_eur, 0) /
+                amdListings.length
+            : 0;
+        // Datacenter/region breakdown
+        const dcMap = new Map();
+        for (const s of listings) {
+            const regions = s.datacenter
+                .split(",")
+                .map((d) => d.trim())
+                .filter(Boolean);
+            for (const region of regions) {
+                const key = `${s.provider.charAt(0).toUpperCase() + s.provider.slice(1)} ${region}`;
+                dcMap.set(key, (dcMap.get(key) ?? 0) + 1);
+            }
+        }
+        const dcLines = [...dcMap.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .map(([dc, n]) => `  ${dc}: ${n} servers`);
+        // RAM tier distribution
+        const ramTiers = new Map();
+        for (const s of listings) {
+            const tier = s.ram_gb >= 256 ? "256+ GB"
+                : s.ram_gb >= 128 ? "128-255 GB"
+                    : s.ram_gb >= 64 ? "64-127 GB"
+                        : s.ram_gb >= 32 ? "32-63 GB"
+                            : "<32 GB";
+            ramTiers.set(tier, (ramTiers.get(tier) ?? 0) + 1);
+        }
+        const ramOrder = [
+            "<32 GB",
+            "32-63 GB",
+            "64-127 GB",
+            "128-255 GB",
+            "256+ GB",
+        ];
+        const ramLines = ramOrder
+            .filter((t) => ramTiers.has(t))
+            .map((t) => `  ${t}: ${ramTiers.get(t)} servers`);
+        const gpuCount = listings.filter((s) => s.gpu).length;
+        const eccCount = listings.filter((s) => s.is_ecc).length;
+        const text = [
+            `Server Auction — Live Statistics`,
+            `=================================`,
+            ``,
+            `Total listings: ${listings.length}`,
+            ``,
+            `Provider:`,
+            ...providerLines,
+            ``,
+            `Price (EUR/month):`,
+            `  Min: \u20AC${prices[0].toFixed(2)}  Max: \u20AC${prices[prices.length - 1].toFixed(2)}  Avg: \u20AC${avg.toFixed(2)}  Median: \u20AC${median.toFixed(2)}`,
+            ``,
+            `CPU Vendor:`,
+            `  Intel: ${intelListings.length} servers (avg \u20AC${intelAvg.toFixed(2)}/mo)`,
+            `  AMD: ${amdListings.length} servers (avg \u20AC${amdAvg.toFixed(2)}/mo)`,
+            ``,
+            `Datacenter Region:`,
+            ...dcLines,
+            ``,
+            `RAM Tiers:`,
+            ...ramLines,
+            ``,
+            `GPU servers: ${gpuCount}`,
+            `ECC servers: ${eccCount}`,
+        ];
+        return { content: [{ type: "text", text: text.join("\n") }] };
+    });
+    server.tool("get_auction_server", "Get full details of a specific auction server by its ID", {
+        server_id: z.string().describe("The server ID (numeric for Hetzner, FQN for OVH)"),
+        provider: providerEnum,
+    }, async (params) => {
+        const listing = await getListingById(params.server_id, params.provider);
+        if (!listing) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Server "${params.server_id}" not found in current listings.`,
+                    },
+                ],
+            };
+        }
+        const providerTag = listing.provider.toUpperCase();
+        const coreStr = listing.cpu_cores !== null ? `, ${listing.cpu_cores} cores` : "";
+        const hourlyStr = listing.price_hourly_eur !== null
+            ? ` (\u20AC${listing.price_hourly_eur.toFixed(4)}/hr)`
+            : "";
+        const setupStr = listing.price_setup_eur > 0
+            ? ` + \u20AC${listing.price_setup_eur.toFixed(2)} setup`
+            : "";
+        const lines = [
+            `[${providerTag}] ${listing.id} — Full Details`,
+            `${"=".repeat(50)}`,
+            ``,
+            `CPU: ${listing.cpu} (${listing.cpu_count} socket${listing.cpu_count > 1 ? "s" : ""}${coreStr})`,
+            `RAM: ${listing.ram_gb} GB${listing.is_ecc ? " (ECC)" : ""}`,
+            `Disks: ${formatDiskSummary(listing)}`,
+            `  Total: ${listing.disk_total_gb} GB across ${listing.disk_count} drive${listing.disk_count > 1 ? "s" : ""}`,
+            `Datacenter: ${listing.datacenter} (${listing.country})`,
+            `Bandwidth: ${formatBandwidth(listing.bandwidth_mbps)}`,
+            ...(listing.gpu
+                ? [`GPU: ${listing.gpu_model ?? "Yes"}`]
+                : []),
+            ``,
+            `Price: \u20AC${listing.price_monthly_eur.toFixed(2)}/mo${hourlyStr}${setupStr}`,
+            `Type: ${formatNextReduce(listing)}`,
+            ...(listing.is_highio ? [`High I/O: Yes`] : []),
+            ...(listing.availability
+                ? [`Availability: ${listing.availability}`]
+                : []),
+            ...(listing.specials.length > 0
+                ? [`Specials: ${listing.specials.join(", ")}`]
+                : []),
+            ``,
+            `View: ${listing.url}`,
+        ];
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    });
+}
+function formatServerLine(s, index) {
+    const providerTag = `[${s.provider.toUpperCase()}]`;
+    const coreStr = s.cpu_cores !== null ? ` (${s.cpu_cores} cores)` : "";
+    const ecc = s.is_ecc ? " (ECC)" : "";
+    const gpu = s.gpu ? ` | GPU: ${s.gpu_model ?? "Yes"}` : "";
+    const disk = formatDiskSummary(s);
+    const priceInfo = formatNextReduce(s);
+    const hourly = s.price_hourly_eur !== null
+        ? ` (\u20AC${s.price_hourly_eur.toFixed(4)}/hr)`
+        : "";
+    return [
+        `${index}. ${providerTag} ${s.id} — ${s.cpu}${coreStr} | ${s.ram_gb} GB RAM${ecc} | ${disk} | ${s.datacenter}`,
+        `   \u20AC${s.price_monthly_eur.toFixed(2)}/mo${hourly} | ${priceInfo}${gpu}`,
+        `   ${s.url}`,
+        ``,
+    ].join("\n");
+}

package/build/types.js

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

package/build/utils.js

@@ -0,0 +1,50 @@
+export function getCpuVendor(cpu) {
+    const lower = cpu.toLowerCase();
+    if (lower.includes("intel") || lower.includes("xeon") || lower.includes("core i"))
+        return "intel";
+    if (lower.includes("amd") || lower.includes("ryzen") || lower.includes("epyc"))
+        return "amd";
+    return "unknown";
+}
+export function formatSize(gb) {
+    if (gb >= 1000)
+        return `${(gb / 1000).toFixed(gb % 1000 === 0 ? 0 : 1)} TB`;
+    return `${gb} GB`;
+}
+export function formatDiskSummary(listing) {
+    if (listing.disks.length === 0)
+        return "No disks";
+    const parts = listing.disks.map((d) => {
+        const typeLabel = d.type === "nvme" ? "NVMe"
+            : d.type === "sata" ? "SATA SSD"
+                : d.type === "hdd" ? "HDD"
+                    : "Disk";
+        return `${d.count}x ${formatSize(d.size_gb)} ${typeLabel}`;
+    });
+    return parts.join(" + ");
+}
+export function getDiskType(listing) {
+    const types = new Set(listing.disks.map((d) => d.type).filter((t) => t !== "unknown"));
+    if (types.size === 0)
+        return "none";
+    if (types.size > 1)
+        return "mixed";
+    return types.values().next().value;
+}
+export function formatBandwidth(mbps) {
+    if (mbps >= 1000)
+        return `${mbps / 1000} Gbit`;
+    return `${mbps} Mbit`;
+}
+export function formatNextReduce(listing) {
+    if (listing.fixed_price || listing.next_reduce_timestamp === null)
+        return "Fixed price";
+    const remaining = listing.next_reduce_timestamp * 1000 - Date.now();
+    if (remaining <= 0)
+        return "Reduction imminent";
+    const hours = Math.floor(remaining / 3600000);
+    const mins = Math.floor((remaining % 3600000) / 60000);
+    if (hours > 0)
+        return `Next reduction in ${hours}h ${mins}m`;
+    return `Next reduction in ${mins}m`;
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "mcp-server-auction",
+  "version": "0.2.0",
+  "description": "MCP server for European dedicated server auctions and listings",
+  "type": "module",
+  "main": "build/index.js",
+  "bin": {
+    "mcp-server-auction": "build/index.js"
+  },
+  "files": [
+    "build"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node build/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "dedicated-server",
+    "hetzner",
+    "ovh",
+    "server-auction"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/raws-labs/mcp-server-auction.git"
+  },
+  "homepage": "https://github.com/raws-labs/mcp-server-auction",
+  "bugs": {
+    "url": "https://github.com/raws-labs/mcp-server-auction/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.24.4"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3",
+    "@types/node": "^22.15.3"
+  },
+  "license": "MIT"
+}