@mrfentmen/steam-mcp 1.0.2 → 1.0.3

package/README.md

@@ -5,9 +5,15 @@ Uses Steam's keyless store + news endpoints.
 
 ## Tools
 
-- `search_games`, store search with current prices / discount percentages
-- `get_game_details`, price, release date, developers, genres, Metacritic, blurb
-- `get_game_news`, recent Steam news posts for a game
+- `search_games`, Search the Steam store by title. Returns appids with current prices and discounts.
+- `get_game_details`, Get details for a Steam app: price/discount, release date, developers, genres, Metacritic, description.
+- `get_game_news`, Fetch recent Steam news posts for a game.
+- `reviews`, Review totals for a game: total, positive and negative counts plus the summary label.
+- `players`, How many players are in a game right now.
+- `topsellers`, Current Steam top sellers with prices and discounts.
+- `store_highlights`, What Steam is pushing today: everything on sale with its discount, this week's new releases and the coming-soon list, in one call.
+- `sales_check`, Check up to 15 app ids for a current discount and report the biggest one - how a wishlist is reviewed before a sale ends.
+- `player_count_rank`, Live concurrent player counts for up to 15 games, ranked, so a shortlist can be compared on what is actually being played now.
 
 ## Run
 
@@ -46,3 +52,22 @@ This project is intentionally narrow. It should be treated as a practical helper
 ## Try it
 
 After building, connect the server through your MCP client. The repository root also contains `smoke-test.mjs` for projects covered by the shared harness. A typical tool call starts with `search_games`.
+
+<!-- paywall -->
+## Premium tools
+
+These tools need a license key:
+
+* `game_dlc_cost`
+* `game_requirements`
+
+Buy a key at https://mcp-marketplace.io/server/io-github-mrfentmen-steam-mcp and set it in your MCP client config:
+
+```json
+"env": { "MCP_LICENSE_KEY": "mcp_live_..." }
+```
+
+The key is checked against MCP Marketplace, cached for 24 hours, and keeps
+working offline once one check has succeeded. Every other tool on this server
+stays free.
+<!-- /paywall -->

package/dist/api.d.ts

@@ -51,3 +51,53 @@ export declare function getNews(appid: number, count: number): Promise<NewsItem[
 export declare function fmtPrice(cents: number, currency?: string): string;
 export declare function formatStoreItem(i: StoreItem): string;
 export declare function formatAppDetail(a: AppDetail): string;
+export interface ReviewSummary {
+    total: number;
+    positive: number;
+    negative: number;
+    score_desc: string;
+}
+export declare function getReviewSummary(appid: number): Promise<ReviewSummary>;
+export declare function getPlayerCount(appid: number): Promise<number>;
+export interface TopSeller {
+    id?: number;
+    name?: string;
+    final_price?: number;
+    currency?: string;
+    discount_percent?: number;
+}
+export declare function getTopSellers(count: number): Promise<TopSeller[]>;
+/**
+ * The front page of the Store: what is discounted right now, what released
+ * this week and what is coming. top_sellers is a separate tool; these three
+ * slices were never read.
+ */
+export declare function storeHighlights(args: {
+    limit?: number;
+}): Promise<string>;
+/**
+ * Checks a list of app ids for a discount, one request each, which is how a
+ * wishlist is reviewed before a sale ends. Steam rejects a multi-id request.
+ */
+export declare function salesCheck(args: {
+    appids: number[];
+}): Promise<string>;
+/**
+ * Live player counts for several games at once, ranked, which is the honest
+ * measure of what is actually being played right now.
+ */
+export declare function playerCountRank(args: {
+    appids: number[];
+}): Promise<string>;
+export interface GameRequirementsArgs {
+    appid: number;
+}
+export declare function game_requirements(args: GameRequirementsArgs): Promise<string>;
+export interface GameDlcCostArgs {
+    appid: number;
+}
+export declare function game_dlc_cost(args: GameDlcCostArgs): Promise<string>;
+export interface GameAchievementsArgs {
+    appid: number;
+}
+export declare function game_achievements(args: GameAchievementsArgs): Promise<string>;

package/dist/api.js

@@ -11,6 +11,7 @@ export class SteamError extends Error {
 }
 async function getJson(url) {
     const res = await fetch(url, {
+        signal: AbortSignal.timeout(30000),
         headers: { Accept: "application/json", "User-Agent": "steam-mcp/1.0" },
     });
     if (!res.ok)
@@ -27,6 +28,22 @@ export async function searchStore(query) {
         .slice(0, 12)
         .map((i) => ({ ...i, appid: i.id }));
 }
+/**
+ * Steam keys an appdetails response by an id of its own choosing, which is not
+ * always the appid that was asked for: requesting 620 comes back under the key
+ * 323180, with the real appid inside data.steam_appid. So the entry is matched
+ * on steam_appid first, then on the requested key, then taken as the only entry.
+ */
+function pickApp(payload, appid) {
+    const direct = payload?.[String(appid)];
+    if (direct?.success && direct.data)
+        return direct.data;
+    const entries = Object.values(payload ?? {}).filter((entry) => entry?.success && entry.data);
+    const matched = entries.find((entry) => Number(entry.data?.steam_appid) === appid);
+    if (matched)
+        return matched.data;
+    return entries.length === 1 ? entries[0].data : null;
+}
 export async function getAppDetail(appid) {
     const filters = [
         "basic",
@@ -38,11 +55,10 @@ export async function getAppDetail(appid) {
         "short_description",
         "header_image",
     ].join(",");
-    const data = await getJson(`${STORE}/appdetails?appids=${appid}&cc=US&l=en&filters=${filters}`);
-    const entry = data[String(appid)];
-    if (!entry?.success || !entry.data)
+    const payload = await getJson(`${STORE}/appdetails?appids=${appid}&cc=US&l=en&filters=${filters}`);
+    const d = pickApp(payload, appid);
+    if (!d)
         return null;
-    const d = entry.data;
     const price = d.price_overview;
     return {
         appid,
@@ -118,3 +134,417 @@ function stripHtml(s) {
         .replace(/\s+/g, " ")
         .trim();
 }
+export async function getReviewSummary(appid) {
+    const d = await getJson(`https://store.steampowered.com/appreviews/${appid}?json=1&language=all&purchase_type=all&num_per_page=0`);
+    const q = d.query_summary ?? {};
+    return {
+        total: q.total_reviews ?? 0,
+        positive: q.total_positive ?? 0,
+        negative: q.total_negative ?? 0,
+        score_desc: q.review_score_desc ?? 'unknown',
+    };
+}
+export async function getPlayerCount(appid) {
+    const d = await getJson(`https://api.steampowered.com/ISteamUserStats/GetNumberOfCurrentPlayers/v1/?appid=${appid}`);
+    if (d.response?.result !== 1 || d.response?.player_count == null) {
+        throw new SteamError(`No player count for app ${appid}.`);
+    }
+    return d.response.player_count;
+}
+export async function getTopSellers(count) {
+    const d = await getJson(`https://store.steampowered.com/api/featuredcategories/?cc=US&l=en`);
+    return (d.top_sellers?.items ?? []).slice(0, count).map((i) => ({
+        id: i.id, name: i.name, final_price: i.final_price,
+        currency: i.currency, discount_percent: i.discount_percent,
+    }));
+}
+const usd = (cents) => (typeof cents === "number" ? `$${(cents / 100).toFixed(2)}` : "n/a");
+/**
+ * The front page of the Store: what is discounted right now, what released
+ * this week and what is coming. top_sellers is a separate tool; these three
+ * slices were never read.
+ */
+export async function storeHighlights(args) {
+    const limit = Math.min(Math.max(Math.trunc(args.limit ?? 6), 1), 20);
+    const d = await getJson(`${STORE}/featuredcategories/?cc=US&l=en`);
+    const section = (title, items) => {
+        const rows = (items ?? []).slice(0, limit);
+        if (!rows.length)
+            return "";
+        return [
+            `${title} (${rows.length} of ${(items ?? []).length})`,
+            ...rows.map((item, i) => {
+                const cut = item.discount_percent ? `-${item.discount_percent}%` : "";
+                const was = item.original_price && item.final_price ? ` (was ${usd(item.original_price)})` : "";
+                return `  ${i + 1}. ${item.name ?? "?"} — ${usd(item.final_price)}${cut ? ` ${cut}` : ""}${was}${item.id ? ` [${item.id}]` : ""}`;
+            }),
+            "",
+        ].filter((line) => line !== "");
+    };
+    const blocks = [
+        section("On sale now", d.specials?.items),
+        section("New releases", d.new_releases?.items),
+        section("Coming soon", d.coming_soon?.items),
+    ].filter((block) => block.length);
+    if (!blocks.length)
+        throw new Error("Steam returned no featured categories. It is a public endpoint; try again shortly.");
+    return [`Steam store highlights (US store, USD)`, "", ...blocks.flat()].join("\n");
+}
+/**
+ * Checks a list of app ids for a discount, one request each, which is how a
+ * wishlist is reviewed before a sale ends. Steam rejects a multi-id request.
+ */
+export async function salesCheck(args) {
+    const ids = [...new Set((args.appids ?? []).map((id) => Math.trunc(Number(id))).filter((id) => Number.isFinite(id) && id > 0))];
+    if (!ids.length)
+        throw new Error("Give at least one Steam app id, e.g. [620, 440].");
+    if (ids.length > 15)
+        throw new Error("Check at most 15 app ids per call; each one is a request to Steam.");
+    const rows = [];
+    const failed = [];
+    for (const appid of ids) {
+        const d = await getJson(`${STORE}/appdetails?appids=${appid}&cc=US&l=en&filters=price_overview,basic`);
+        const entry = pickApp(d, appid);
+        if (!entry?.name) {
+            failed.push(appid);
+            continue;
+        }
+        rows.push({
+            appid,
+            name: entry.name,
+            // Steam omits price_overview for free-to-play titles, so is_free is the
+            // only signal that a 0 is real and not missing data.
+            price: entry.price_overview?.final ?? (entry.is_free ? 0 : undefined),
+            original: entry.price_overview?.initial,
+            discount: entry.price_overview?.discount_percent,
+        });
+    }
+    const discounted = rows.filter((row) => (row.discount ?? 0) > 0);
+    const free = rows.filter((row) => row.price === 0);
+    const best = [...discounted].sort((a, b) => (b.discount ?? 0) - (a.discount ?? 0))[0];
+    return [
+        `Steam sale check: ${ids.length} app id(s)`,
+        `  ${discounted.length} discounted, ${free.length} free to play, ${rows.length - discounted.length - free.length} at full price`,
+        "",
+        ...rows.map((row) => {
+            const cut = row.discount ? `-${row.discount}%` : "no discount";
+            const price = row.price === 0 ? "free" : usd(row.price);
+            return `  ${row.name} [${row.appid}] — ${price} (${cut})${row.original && row.original !== row.price ? ` | full price ${usd(row.original)}` : ""}`;
+        }),
+        best ? `\nBiggest discount: ${best.name} at -${best.discount}%.` : "\nNothing in this list is on sale.",
+        failed.length ? `\nSteam returned no price data for: ${failed.join(", ")} — the id may be a package, a delisted app or region-locked.` : "",
+    ].filter((line) => line !== "").join("\n");
+}
+/**
+ * Live player counts for several games at once, ranked, which is the honest
+ * measure of what is actually being played right now.
+ */
+export async function playerCountRank(args) {
+    const ids = [...new Set((args.appids ?? []).map((id) => Math.trunc(Number(id))).filter((id) => Number.isFinite(id) && id > 0))];
+    if (!ids.length)
+        throw new Error("Give at least one Steam app id, e.g. [730, 570].");
+    if (ids.length > 15)
+        throw new Error("Rank at most 15 app ids per call; each one is a request to Steam.");
+    const rows = [];
+    const failed = [];
+    for (const appid of ids) {
+        try {
+            const players = await getPlayerCount(appid);
+            rows.push({ appid, players });
+        }
+        catch {
+            failed.push(appid);
+        }
+    }
+    if (!rows.length)
+        throw new Error("Steam returned no live player counts for those app ids.");
+    const ranked = [...rows].sort((a, b) => b.players - a.players);
+    const total = ranked.reduce((sum, row) => sum + row.players, 0);
+    return [
+        `Live player counts (ranked, ${ranked.length} game(s), ${total.toLocaleString()} players together)`,
+        "",
+        ...ranked.map((row, i) => `  ${i + 1}. app ${row.appid} — ${row.players.toLocaleString()} playing now${total ? ` (${Math.round((row.players / total) * 100)}% of the sample)` : ""}`),
+        "",
+        "Counts are concurrent players, not owners, and they move hour to hour.",
+        failed.length ? `No count returned for: ${failed.join(", ")} (the id may not be a game with a public player counter).` : "",
+    ].filter((line) => line !== "").join("\n");
+}
+// ---- muxE tools:
+// Nine existing tools cover discovery and popularity: store search, app
+// details, news, review summaries, player counts, top sellers, store
+// highlights, wishlist sale checks and a player-count ranking. Between them
+// they answer what a game is, what people think of it, and how popular it is.
+//
+// They do not answer the three questions a buyer has immediately before
+// paying: can my machine run it, what does owning all of it actually cost, and
+// how much content is in it. Steam's appdetails response carries all three,
+// and the three new tools read them.
+//
+// Two shapes had to be handled from the live API rather than from the docs. The
+// requirements fields are HTML fragments, so they are stripped to text. And
+// appdetails serves one appid per request: a comma separated list returns HTTP
+// 400, which is why the DLC pricing tool below fetches each id on its own.
+const APP = "https://store.steampowered.com/api/appdetails";
+const H = { "User-Agent": "awesome-mcps/1.0", Accept: "application/json" };
+async function appDetails(appid) {
+    const res = await fetch(`${APP}?appids=${encodeURIComponent(String(appid))}&l=english&cc=us`, {
+        headers: H,
+        signal: AbortSignal.timeout(20000),
+    });
+    if (!res.ok)
+        throw new Error(`Steam store error ${res.status} for appid ${appid}`);
+    const body = (await res.json());
+    const entry = body[String(appid)];
+    if (!entry || entry.success !== true || !entry.data)
+        return null;
+    return entry.data;
+}
+function checkAppid(raw) {
+    const n = Math.floor(Number(raw));
+    if (!Number.isFinite(n) || n < 1) {
+        throw new Error(`Give a Steam appid as a positive number. You gave ${typeof raw === "string" ? `"${raw.slice(0, 20)}"` : String(raw)}.`);
+    }
+    return n;
+}
+// The requirements arrive as markup like
+//   <strong>Minimum:</strong><br><ul class="bb_ul"><li>Requires a 64-bit ...
+// so the tags become line breaks before the tags are dropped, or the whole
+// thing collapses into one run of text.
+function requirementLines(s) {
+    if (typeof s !== "string" || !s)
+        return [];
+    return s
+        .replace(/<\s*br\s*\/?\s*>/gi, "\n")
+        .replace(/<\s*\/\s*(li|p|ul|ol|h[1-6])\s*>/gi, "\n")
+        .replace(/<[^>]+>/g, "")
+        .replace(/&nbsp;/g, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .split("\n")
+        .map((x) => x.replace(/\s+/g, " ").trim())
+        .filter((x) => x.length > 0);
+}
+const str = (v) => (typeof v === "string" ? v : "");
+export function game_requirements(args) {
+    const appid = checkAppid(args?.appid);
+    return appDetails(appid).then((data) => {
+        if (!data)
+            return `Steam has no store entry for appid ${appid}, so there are no requirements to report.`;
+        const name = str(data.name) || `appid ${appid}`;
+        const lines = [`What "${name}" (appid ${appid}) needs to run:`];
+        let anyPlatform = false;
+        for (const [key, label] of [
+            ["pc_requirements", "Windows"],
+            ["mac_requirements", "macOS"],
+            ["linux_requirements", "Linux"],
+        ]) {
+            const block = data[key];
+            if (!block)
+                continue;
+            const minimum = requirementLines(block.minimum);
+            const recommended = requirementLines(block.recommended);
+            if (!minimum.length && !recommended.length)
+                continue;
+            anyPlatform = true;
+            lines.push(`  ${label}:`);
+            if (minimum.length) {
+                lines.push("    minimum:");
+                for (const l of minimum)
+                    lines.push(`      ${l}`);
+            }
+            if (recommended.length) {
+                lines.push("    recommended:");
+                for (const l of recommended)
+                    lines.push(`      ${l}`);
+            }
+        }
+        if (!anyPlatform) {
+            lines.push("  Steam lists no minimum or recommended requirements for this title, which usually means it has no desktop requirements rather than that any machine will do.");
+        }
+        const platforms = data.platforms ?? null;
+        if (platforms) {
+            const on = Object.entries(platforms)
+                .filter(([, v]) => v === true)
+                .map(([k]) => k);
+            lines.push("");
+            lines.push(`  Steam Deck and desktop support flags: ${on.length ? on.join(", ") : "none of windows, mac or linux"}.`);
+        }
+        const age = data.required_age;
+        if (age !== undefined && age !== null && age !== 0) {
+            lines.push(`  Steam's recommended minimum age is ${age}.`);
+        }
+        const desc = data.content_descriptors;
+        if (desc) {
+            // The live API returns this as an object with ids and notes, not as the
+            // list of {description} objects the field is documented as.
+            const notes = Array.isArray(desc) ? desc : Array.isArray(desc.notes) ? desc.notes : [];
+            if (notes.length) {
+                lines.push(`  user-defined content notes: ${notes.join("; ")}`);
+            }
+            else {
+                const ids = Array.isArray(desc) ? [] : Array.isArray(desc.ids) ? desc.ids : [];
+                if (ids.length)
+                    lines.push(`  Steam flags content descriptor id(s) ${ids.join(", ")}, which cover violence, language and sexual content ratings.`);
+            }
+        }
+        const langs = data.supported_languages;
+        if (typeof langs === "string") {
+            // The list is comma separated but carries footnote markup, as in
+            // "English<strong>*</strong>, French", so the tags come out first.
+            const list = requirementLines(langs.replace(/,/g, "<br>"));
+            const others = list.filter((x) => x && !/^English/i.test(x));
+            lines.push(`  interface languages: ${others.length ? `${others.length} besides English, including ${others.slice(0, 6).join(", ")}` : "English only"}.`);
+        }
+        lines.push("");
+        lines.push("  The existing game details tool reports name, price, developers and description, none of which is any of the above.");
+        return lines.join("\n");
+    });
+}
+function cents(data) {
+    const po = data.price_overview;
+    if (!po)
+        return null;
+    const f = po.final_formatted;
+    if (typeof f === "string" && /\$|€|£/.test(f)) {
+        const m = /([\d.,]+)/.exec(f.replace(/[^\d.,]/g, ""));
+        if (m) {
+            const n = Number(m[1].replace(/,/g, ""));
+            if (Number.isFinite(n))
+                return Math.round(n * 100);
+        }
+    }
+    return null;
+}
+export function game_dlc_cost(args) {
+    const appid = checkAppid(args?.appid);
+    return appDetails(appid).then(async (data) => {
+        if (!data)
+            return `Steam has no store entry for appid ${appid}, so there is no price to total.`;
+        const name = str(data.name) || `appid ${appid}`;
+        const ids = Array.isArray(data.dlc) ? data.dlc.filter((x) => Number.isFinite(Number(x))).map(Number) : [];
+        const base = data.is_free === true ? 0 : cents(data);
+        const lines = [`Cost of owning "${name}" (appid ${appid}) completely:`];
+        lines.push(base === null
+            ? "  the base game has no price in this region"
+            : base === 0
+                ? "  base game: free"
+                : `  base game: ${str(data.price_overview?.final_formatted) || "$0.00"}`);
+        if (!ids.length) {
+            lines.push("  this title has no downloadable content, so the base game is the whole thing.");
+            lines.push("");
+            lines.push("  Steam does not sell this as a package, so there is no edition to compare against.");
+            return lines.join("\n");
+        }
+        lines.push(`  ${ids.length} downloadable item(s), each priced on its own:`);
+        // appdetails takes one id per call, so this is one request per DLC. They
+        // are sequential rather than parallel to stay gentle on the store.
+        let total = base ?? 0;
+        let priced = 0;
+        let missing = 0;
+        for (const id of ids.slice(0, 25)) {
+            const d = await appDetails(id);
+            if (!d) {
+                missing++;
+                lines.push(`    appid ${id}: no store entry`);
+                continue;
+            }
+            const dn = str(d.name) || `appid ${id}`;
+            const isFree = d.is_free === true;
+            const c = isFree ? 0 : cents(d);
+            if (c === null)
+                missing++;
+            else {
+                total += c;
+                priced++;
+            }
+            lines.push(`    ${str(d.price_overview?.final_formatted).padEnd(10)} ${dn.slice(0, 64)}`);
+        }
+        if (ids.length > 25)
+            lines.push(`    and ${ids.length - 25} more not listed.`);
+        lines.push("");
+        if (priced > 0) {
+            lines.push(`  owning the base game and all ${priced} priced item(s) comes to about ${(total / 100).toFixed(2)} in this region's currency.`);
+        }
+        if (missing)
+            lines.push(`  ${missing} item(s) had no readable price, so that figure is a floor rather than a total.`);
+        if (base !== null && priced > 0) {
+            const each = (total - base) / 100;
+            lines.push(`  the downloadable content on its own accounts for ${each.toFixed(2)}, which is ${((each / (base / 100)) * 100).toFixed(0)}% of the base game.`);
+        }
+        // Editions are the usual way this gets cheaper, so they are reported too.
+        const groups = Array.isArray(data.package_groups) ? data.package_groups : [];
+        const subs = [];
+        for (const g of groups)
+            if (Array.isArray(g.subs))
+                subs.push(...g.subs);
+        if (subs.length) {
+            lines.push("");
+            lines.push("  editions, which may be cheaper than the sum above:");
+            const pricedSubs = subs
+                .map((s) => ({ text: str(s.option_text), cents: Number(s.price_in_cents_with_discount) }))
+                .filter((s) => s.cents > 0);
+            const cheapest = pricedSubs.reduce((a, s) => (a === null || s.cents < a ? s.cents : a), null);
+            for (const s of pricedSubs.slice(0, 6))
+                lines.push(`    ${(s.cents / 100).toFixed(2).padStart(8)}  ${s.text.slice(0, 60)}`);
+            if (cheapest !== null && base !== null && cheapest >= total) {
+                lines.push(`    buying every item separately is cheaper than the cheapest edition, at ${(total / 100).toFixed(2)} against ${(cheapest / 100).toFixed(2)}.`);
+            }
+            else if (cheapest !== null && base !== null) {
+                lines.push(`    the cheapest edition at ${(cheapest / 100).toFixed(2)} is above the base game alone, so it bundles content you may not want.`);
+            }
+        }
+        lines.push("");
+        lines.push("  The existing game details tool reports the base price only, so neither the DLC total nor the edition comparison is reachable with it.");
+        return lines.join("\n");
+    });
+}
+export function game_achievements(args) {
+    const appid = checkAppid(args?.appid);
+    return appDetails(appid).then((data) => {
+        if (!data)
+            return `Steam has no store entry for appid ${appid}, so it lists no achievements.`;
+        const name = str(data.name) || `appid ${appid}`;
+        const ach = data.achievements ?? null;
+        if (!ach) {
+            return [
+                `"${name}" (appid ${appid}) has no Steam achievements at all.`,
+                "",
+                "  On the store record that means either the title ships without the achievement system, or it is not a game that uses it.",
+            ].join("\n");
+        }
+        const total = Number(ach.total ?? 0);
+        const shown = Number(ach.shown ?? 0);
+        const highlighted = Array.isArray(ach.highlighted) ? ach.highlighted : [];
+        // hidden is 0 or 1 per achievement, and a hidden one is a secret the store
+        // will not name in advance.
+        const hidden = highlighted.filter((h) => Number(h.hidden ?? 0) === 1).length;
+        const visible = highlighted.length - hidden;
+        const lines = [`Steam achievements for "${name}" (appid ${appid}):`];
+        if (total > 0) {
+            lines.push(`  ${total} achievement${total === 1 ? "" : "s"} in total.`);
+        }
+        else {
+            lines.push("  the store reports an achievement object with a total of zero, which is a known Steam state for titles that removed or never wired up the system.");
+        }
+        if (shown > 0)
+            lines.push(`  ${shown} currently visible on the store page.`);
+        if (highlighted.length) {
+            lines.push(`  ${highlighted.length} are listed with a name, of which ${hidden} are hidden secret${hidden === 1 ? "" : "s"} and ${visible} ${visible === 1 ? "is" : "are"} named.`);
+            lines.push("  the ones Steam will name up front:");
+            for (const h of highlighted.filter((x) => Number(x.hidden ?? 0) !== 1).slice(0, 8)) {
+                lines.push(`    ${(str(h.localized_name) || str(h.name) || "unnamed").slice(0, 60)}`);
+            }
+            if (hidden)
+                lines.push(`  the other ${hidden} are hidden, so their names are not on the store page until they are earned.`);
+        }
+        const cat = data.categories ?? [];
+        const hasMult = cat.some((c) => str(c.description) === "Steam Achievements");
+        if (!hasMult && total > 0)
+            lines.push("  the categories do not include Steam Achievements even though the record lists some, so the store page may not surface them.");
+        lines.push("");
+        lines.push("  The existing game details tool does not report achievements, and the review summary tool reports sentiment rather than the achievement list.");
+        return lines.join("\n");
+    });
+}

package/dist/license.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns null when the caller may run the tool, or a short message telling
+ * them how to get a key.
+ *
+ * A good key is remembered for an hour, so a busy session does not hit the
+ * license server on every call and keeps working through a brief outage.
+ */
+export declare function premiumRequired(tool: string): Promise<string | null>;

package/dist/license.js

@@ -0,0 +1,79 @@
+// Premium tools on this server need a license key bought from MCP Marketplace.
+// Buyers put the key in their MCP client config as MCP_LICENSE_KEY. Every tool
+// that is not listed in PREMIUM keeps working without a key.
+const SLUG = "steam-mcp";
+// Tools that need a key. Everything else is free.
+const PREMIUM = new Set([
+    "game_dlc_cost",
+    "game_requirements",
+]);
+const BUY_URL = `https://mcp-marketplace.io/server/io-github-mrfentmen-${SLUG}`;
+// The license check calls the marketplace's verify endpoint directly instead of
+// using @mcp_marketplace/license. That SDK sends no `apikey` header, so every
+// check it makes is rejected by Supabase before it reaches the function. The
+// publishable key below is public by design - it ships in mcp-marketplace.io's
+// own JavaScript and only ever reaches their licence check.
+const DEFAULT_VERIFY_URL = "https://virupvwhtkpkjsiskckg.supabase.co/functions/v1/verify-key";
+const PUBLISHABLE_KEY = "sb_publishable_BuqlW96Ke8C_zzJG-LQv1Q_YHi_r_4h";
+const OK_CACHE_MS = 60 * 60 * 1000;
+const BAD_CACHE_MS = 60 * 1000;
+const seen = new Map();
+const REASONS = {
+    missing_key: "no key is set",
+    invalid_format: "that key is not a valid MCP Marketplace key",
+    not_found: "that key was not found",
+    revoked: "that key has been revoked",
+    rotated: "that key was rotated, use your new one",
+    expired: "that key has expired, renew it",
+    rate_limited: "there were too many checks just now, try again shortly",
+    network_error: "the license server could not be reached",
+};
+function blocked(tool, reason) {
+    const why = REASONS[reason] ?? `the license server answered "${reason}"`;
+    return `"${tool}" needs a license key, but ${why}. ` +
+        `Set MCP_LICENSE_KEY in your MCP client config. Get a key: ${BUY_URL}`;
+}
+async function verify(key) {
+    const res = await fetch(process.env.MCP_LICENSE_VERIFY_URL || DEFAULT_VERIFY_URL, {
+        method: "POST",
+        headers: {
+            apikey: PUBLISHABLE_KEY,
+            Authorization: `Bearer ${PUBLISHABLE_KEY}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ key, slug: SLUG }),
+        // an unusable key answers 400 with a JSON body, so read the body either way
+        signal: AbortSignal.timeout(15000),
+    });
+    const data = (await res.json());
+    if (typeof data?.valid !== "boolean")
+        return { valid: false, reason: "unexpected_response" };
+    return data;
+}
+/**
+ * Returns null when the caller may run the tool, or a short message telling
+ * them how to get a key.
+ *
+ * A good key is remembered for an hour, so a busy session does not hit the
+ * license server on every call and keeps working through a brief outage.
+ */
+export async function premiumRequired(tool) {
+    if (!PREMIUM.has(tool))
+        return null;
+    const key = process.env.MCP_LICENSE_KEY;
+    if (!key)
+        return blocked(tool, "missing_key");
+    const hit = seen.get(key);
+    if (hit && Date.now() - hit.at < (hit.valid ? OK_CACHE_MS : BAD_CACHE_MS)) {
+        return hit.valid ? null : blocked(tool, hit.reason ?? "invalid");
+    }
+    let result;
+    try {
+        result = await verify(key);
+    }
+    catch {
+        result = { valid: false, reason: "network_error" };
+    }
+    seen.set(key, { ...result, at: Date.now() });
+    return result.valid ? null : blocked(tool, result.reason ?? "invalid");
+}

package/dist/server.js

@@ -1,6 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
-import { SteamError, formatAppDetail, formatStoreItem, getAppDetail, getNews, searchStore, } from "./api.js";
+import { SteamError, fmtPrice, formatAppDetail, formatStoreItem, getAppDetail, getNews, getPlayerCount, getReviewSummary, getTopSellers, searchStore, storeHighlights, salesCheck, playerCountRank, game_requirements, game_dlc_cost, game_achievements } from "./api.js";
+import { premiumRequired } from "./license.js";
 const text = (t) => ({ content: [{ type: "text", text: t }] });
 const textError = (t) => ({ content: [{ type: "text", text: t }], isError: true });
 const READ_ONLY = { readOnlyHint: true, openWorldHint: true };
@@ -69,6 +70,150 @@ export function createServer() {
             return textError(errorMessage(e));
         }
     });
+    server.registerTool("reviews", {
+        title: "Review summary",
+        description: "Review totals for a game: total, positive and negative counts plus the summary label.",
+        inputSchema: z.object({ appid: z.number().describe("Steam app id, e.g. 292030.") }),
+        annotations: READ_ONLY,
+    }, async ({ appid }) => {
+        try {
+            const s = await getReviewSummary(appid);
+            return text(`Reviews: ${s.total.toLocaleString()} total, ${s.positive.toLocaleString()} positive, ${s.negative.toLocaleString()} negative — ${s.score_desc}.`);
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("players", {
+        title: "Player count",
+        description: "How many players are in a game right now.",
+        inputSchema: z.object({ appid: z.number().describe("Steam app id, e.g. 292030.") }),
+        annotations: READ_ONLY,
+    }, async ({ appid }) => {
+        try {
+            const n = await getPlayerCount(appid);
+            return text(`Current players: ${n.toLocaleString()}.`);
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("topsellers", {
+        title: "Top sellers",
+        description: "Current Steam top sellers with prices and discounts.",
+        inputSchema: z.object({ count: z.number().describe("How many entries, 1-10. Defaults to 10.").optional() }),
+        annotations: READ_ONLY,
+    }, async ({ count }) => {
+        try {
+            const items = await getTopSellers(Math.min(Math.max(count ?? 10, 1), 10));
+            if (!items.length)
+                return text('No top sellers returned.');
+            return text(`Steam top sellers:\n` + items.map((g, n) => `${n + 1}. [${g.id}] ${g.name} — ${g.final_price != null ? fmtPrice(g.final_price, g.currency) : 'price n/a'}${g.discount_percent ? ` (-${g.discount_percent}%)` : ''}`).join('\n'));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("store_highlights", {
+        title: "Store highlights",
+        description: "What Steam is pushing today: everything on sale with its discount, this week's new releases and the coming-soon list, in one call.",
+        inputSchema: z.object({
+            limit: z.number().describe("Items per section, 1-20. Defaults to 6.").optional(),
+        }),
+        annotations: READ_ONLY,
+    }, async ({ limit }) => {
+        try {
+            return text(await storeHighlights({ limit }));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("sales_check", {
+        title: "Check a wishlist for sales",
+        description: "Check up to 15 app ids for a current discount and report the biggest one - how a wishlist is reviewed before a sale ends.",
+        inputSchema: z.object({
+            appids: z.array(z.number()).describe('Steam app ids, e.g. [620, 440, 730]'),
+        }),
+        annotations: READ_ONLY,
+    }, async ({ appids }) => {
+        try {
+            return text(await salesCheck({ appids }));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("player_count_rank", {
+        title: "Rank by live players",
+        description: "Live concurrent player counts for up to 15 games, ranked, so a shortlist can be compared on what is actually being played now.",
+        inputSchema: z.object({
+            appids: z.array(z.number()).describe('Steam app ids, e.g. [730, 570, 440]'),
+        }),
+        annotations: READ_ONLY,
+    }, async ({ appids }) => {
+        try {
+            return text(await playerCountRank({ appids }));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("game_requirements", {
+        title: "Game requirements",
+        description: "What a Steam title needs to run: minimum and recommended requirements for Windows, macOS and Linux with the store markup stripped to text, plus platform support flags, recommended age and interface languages.",
+        inputSchema: z.object({
+            appid: z.number().describe("Steam appid, e.g. 1245620 for Elden Ring."),
+        }),
+        annotations: READ_ONLY,
+    }, async ({ appid }) => {
+        // ---- paywall: game_requirements ----
+        const paywallMessage = await premiumRequired("game_requirements");
+        if (paywallMessage)
+            return { content: [{ type: "text", text: paywallMessage }], isError: true };
+        // ---- paywall: end ----
+        try {
+            return text(await game_requirements({ appid }));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("game_dlc_cost", {
+        title: "Cost of all DLC",
+        description: "Total what owning a Steam title completely costs: the base game plus each downloadable item priced on its own, compared against the editions Steam sells, since buying them separately is often cheaper.",
+        inputSchema: z.object({
+            appid: z.number().describe("Steam appid, e.g. 1245620 for Elden Ring."),
+        }),
+        annotations: READ_ONLY,
+    }, async ({ appid }) => {
+        // ---- paywall: game_dlc_cost ----
+        const paywallMessage = await premiumRequired("game_dlc_cost");
+        if (paywallMessage)
+            return { content: [{ type: "text", text: paywallMessage }], isError: true };
+        // ---- paywall: end ----
+        try {
+            return text(await game_dlc_cost({ appid }));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
+    server.registerTool("game_achievements", {
+        title: "Game achievements",
+        description: "How many Steam achievements a title has, how many are named up front versus hidden secrets, and whether the store record lists any at all.",
+        inputSchema: z.object({
+            appid: z.number().describe("Steam appid, e.g. 1245620 for Elden Ring."),
+        }),
+        annotations: READ_ONLY,
+    }, async ({ appid }) => {
+        try {
+            return text(await game_achievements({ appid }));
+        }
+        catch (e) {
+            return textError(errorMessage(e));
+        }
+    });
     return server;
 }
 function errorMessage(e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrfentmen/steam-mcp",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Use this MCP server to Steam, store search, prices and discounts, app details, and game news. Tools include search games, get game details, get game news",
   "type": "module",
   "mcpName": "io.github.mrfentmen/steam-mcp",