npm - snowbll-mcp - Versions diffs - 0.2.3 → 0.2.4 - Mend

snowbll-mcp 0.2.3 → 0.2.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/LICENSE CHANGED Viewed

@@ -1,21 +1,21 @@
-MIT License
-Copyright (c) 2026 Snowbll
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+Copyright (c) 2026 Snowbll
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md CHANGED Viewed

@@ -1,122 +1,122 @@
-# Snowbll MCP + CLI
-**Search the Snowbll game catalog, read your gaming persona, and follow Forge campaigns — from any MCP-capable AI agent or your terminal.**
-Everything in this package talks to the **live Snowbll API** (`https://www.snowbll.com`). There is no mock data.
-Status: the search and Forge tools hit live public endpoints; the MCP servers, API keys, and the keyed v1 endpoints are in **developer preview** — names, fields, auth, and quotas may change before launch.
-Two binaries ship in one package:
-| Binary | What it is |
-| --- | --- |
-| `snowbll-mcp` | [Model Context Protocol](https://modelcontextprotocol.io) server over stdio — launched by agents (Claude, Cursor, Hermes, …) |
-| `snowbll` | CLI for humans — search, persona, Forge, key management |
-There is also a **hosted remote MCP server (developer preview)** at `https://www.snowbll.com/api/mcp` (Streamable HTTP) for clients that connect to URLs instead of launching processes — ChatGPT connectors, Claude custom connectors, Hermes remote MCP. It is an **OAuth 2.1 protected resource**: MCP clients start the sign-in flow automatically on connect (no manual key needed); persona access uses the `persona.read` scope.
-## Tools
-The MCP surface is deliberately read-only: tools recommend, explain, and retrieve. Nothing here buys games, backs campaigns, or moves money.
-| Tool | What it does | Needs API key? |
-| --- | --- | --- |
-| `search_games` | Natural-language catalog search with ranked candidates + reasons | No |
-| `get_game` | Full metadata for one game, incl. human-verification status | No |
-| `get_persona` | The key owner's gaming persona — a playstyle + taste summary from their library and playtime (consent-scoped) | Yes — data visible from the **Observer** rank up; free accounts get a locked marker |
-| `list_forge_campaigns` | Forge campaigns with live funding totals | No |
-| `get_forge_campaign` | One campaign: tiers, stretch goals, progress | No |
-Honesty model: `verification` is `verified` only after third-party human testing; quality fields (`graphicsFidelity`, `economyComplexity`) are `null` until a human rated them. AI recommends, humans judge.
-## Quick start (agents)
-### Claude Code
-Hosted (remote, OAuth — no install):
-```bash
-claude mcp add --transport http snowbll https://www.snowbll.com/api/mcp
-```
-Then run `/mcp` and complete the OAuth sign-in when prompted — no manual key needed. Persona access uses the `persona.read` scope.
-Or run it locally over stdio (uses `SNOWBLL_API_KEY` if set — see below):
-```bash
-claude mcp add snowbll -- npx -y snowbll-mcp
-```
-### Claude Desktop / Cursor / Windsurf / Hermes (stdio)
-```json
-{
-  "mcpServers": {
-    "snowbll": {
-      "command": "npx",
-      "args": ["-y", "snowbll-mcp"],
-      "env": { "SNOWBLL_API_KEY": "sb_YOUR_API_KEY" }
-    }
-  }
-}
-```
-Omit the `env` block to run keyless (search, game lookups, and Forge tools still work — only `get_persona` needs a key).
-### ChatGPT (remote connector — no install)
-1. Settings → Connectors (requires a plan with connectors/developer mode).
-2. Add a custom connector with URL `https://www.snowbll.com/api/mcp`, then complete the OAuth sign-in when prompted — no manual key needed. Persona access uses the `persona.read` scope.
-3. Ask: *"Use Snowbll to find an economy sim like Lemonade Tycoon with a deep economy."*
-The remote server also implements OpenAI's `search` / `fetch` connector contract, so it works in ChatGPT deep research too.
-### Claude (claude.ai custom connector / remote)
-Add a custom connector with URL `https://www.snowbll.com/api/mcp` and complete the OAuth sign-in when prompted — no manual key needed. The catalog and Forge tools (`search_games`, `get_game`, `list_forge_campaigns`, `get_forge_campaign`) are free once connected; `get_persona` is consent-scoped via `persona.read`.
-### Verify any setup
-Ask the agent:
-> Use search_games to find: "economy sim like Lemonade Tycoon with a deep economy"
-A working setup returns a short candidate list, each with `reasons`.
-## Quick start (humans)
-```bash
-npm install -g snowbll-mcp
-snowbll search "cozy farming game with deep crafting"
-snowbll forge                 # campaigns on The Forge
-snowbll login                 # mint + store an API key (email+password account)
-snowbll whoami
-snowbll persona               # your gaming persona
-snowbll setup                 # wizard + ready-to-paste agent configs
-```
-## API keys (developer preview)
-Keys (`sb_…`) belong to Snowbll accounts and are hashed at rest — the plaintext is shown once.
-- `snowbll login` — sign in with an email+password Snowbll account; mints and stores a key in `~/.snowbll/config.json`.
-- Accounts created with Google/Discord have no password: ask the Snowbll team for a preview key, then `snowbll setup` to paste it.
-- `snowbll keys list|create|revoke` manages keys; `SNOWBLL_API_KEY` env always wins over the stored key.
-Keep keys out of browser code, public repos, and shared transcripts.
-## Configuration
-| Env var | Default | Purpose |
-| --- | --- | --- |
-| `SNOWBLL_API_KEY` | – | Developer-preview API key |
-| `SNOWBLL_API_BASE` | `https://www.snowbll.com` | API origin (point at a local dev server while developing) |
-## REST instead?
-Everything the tools do is plain HTTP — `POST https://www.snowbll.com/api/search` is live with no key. Full docs: <https://www.snowbll.com/docs>.
-## License
-MIT
+# Snowbll MCP + CLI
+**Search the Snowbll game catalog, read your gaming persona, and follow Forge campaigns — from any MCP-capable AI agent or your terminal.**
+Everything in this package talks to the **live Snowbll API** (`https://www.snowbll.com`). There is no mock data.
+Status: the search and Forge tools hit live public endpoints; the MCP servers, API keys, and the keyed v1 endpoints are in **developer preview** — names, fields, auth, and quotas may change before launch.
+Two binaries ship in one package:
+| Binary | What it is |
+| --- | --- |
+| `snowbll-mcp` | [Model Context Protocol](https://modelcontextprotocol.io) server over stdio — launched by agents (Claude, Cursor, Hermes, …) |
+| `snowbll` | CLI for humans — search, persona, Forge, key management |
+There is also a **hosted remote MCP server (developer preview)** at `https://www.snowbll.com/api/mcp` (Streamable HTTP) for clients that connect to URLs instead of launching processes — ChatGPT connectors, Claude custom connectors, Hermes remote MCP. It is an **OAuth 2.1 protected resource**: MCP clients start the sign-in flow automatically on connect (no manual key needed); persona access uses the `persona.read` scope.
+## Tools
+The MCP surface is deliberately read-only: tools recommend, explain, and retrieve. Nothing here buys games, backs campaigns, or moves money.
+| Tool | What it does | Needs API key? |
+| --- | --- | --- |
+| `search_games` | Natural-language catalog search with ranked candidates + reasons | No |
+| `get_game` | Full metadata for one game, incl. human-verification status | No |
+| `get_persona` | The key owner's gaming persona — a playstyle + taste summary from their library and playtime (consent-scoped) | Yes — data visible from the **Observer** rank up; free accounts get a locked marker |
+| `list_forge_campaigns` | Forge campaigns with live funding totals | No |
+| `get_forge_campaign` | One campaign: tiers, stretch goals, progress | No |
+Honesty model: `verification` is `verified` only after third-party human testing; quality fields (`graphicsFidelity`, `economyComplexity`) are `null` until a human rated them. AI recommends, humans judge.
+## Quick start (agents)
+### Claude Code
+Hosted (remote, OAuth — no install):
+```bash
+claude mcp add --transport http snowbll https://www.snowbll.com/api/mcp
+```
+Then run `/mcp` and complete the OAuth sign-in when prompted — no manual key needed. Persona access uses the `persona.read` scope.
+Or run it locally over stdio (uses `SNOWBLL_API_KEY` if set — see below):
+```bash
+claude mcp add snowbll -- npx -y snowbll-mcp
+```
+### Claude Desktop / Cursor / Windsurf / Hermes (stdio)
+```json
+{
+  "mcpServers": {
+    "snowbll": {
+      "command": "npx",
+      "args": ["-y", "snowbll-mcp"],
+      "env": { "SNOWBLL_API_KEY": "sb_YOUR_API_KEY" }
+    }
+  }
+}
+```
+Omit the `env` block to run keyless (search, game lookups, and Forge tools still work — only `get_persona` needs a key).
+### ChatGPT (remote connector — no install)
+1. Settings → Connectors (requires a plan with connectors/developer mode).
+2. Add a custom connector with URL `https://www.snowbll.com/api/mcp`, then complete the OAuth sign-in when prompted — no manual key needed. Persona access uses the `persona.read` scope.
+3. Ask: *"Use Snowbll to find an economy sim like Lemonade Tycoon with a deep economy."*
+The remote server also implements OpenAI's `search` / `fetch` connector contract, so it works in ChatGPT deep research too.
+### Claude (claude.ai custom connector / remote)
+Add a custom connector with URL `https://www.snowbll.com/api/mcp` and complete the OAuth sign-in when prompted — no manual key needed. The catalog and Forge tools (`search_games`, `get_game`, `list_forge_campaigns`, `get_forge_campaign`) are free once connected; `get_persona` is consent-scoped via `persona.read`.
+### Verify any setup
+Ask the agent:
+> Use search_games to find: "economy sim like Lemonade Tycoon with a deep economy"
+A working setup returns a short candidate list, each with `reasons`.
+## Quick start (humans)
+```bash
+npm install -g snowbll-mcp
+snowbll search "cozy farming game with deep crafting"
+snowbll forge                 # campaigns on The Forge
+snowbll login                 # mint + store an API key (email+password account)
+snowbll whoami
+snowbll persona               # your gaming persona
+snowbll setup                 # wizard + ready-to-paste agent configs
+```
+## API keys (developer preview)
+Keys (`sb_…`) belong to Snowbll accounts and are hashed at rest — the plaintext is shown once.
+- `snowbll login` — sign in with an email+password Snowbll account; mints and stores a key in `~/.snowbll/config.json`.
+- Accounts created with Google/Discord have no password: ask the Snowbll team for a preview key, then `snowbll setup` to paste it.
+- `snowbll keys list|create|revoke` manages keys; `SNOWBLL_API_KEY` env always wins over the stored key.
+Keep keys out of browser code, public repos, and shared transcripts.
+## Configuration
+| Env var | Default | Purpose |
+| --- | --- | --- |
+| `SNOWBLL_API_KEY` | – | Developer-preview API key |
+| `SNOWBLL_API_BASE` | `https://www.snowbll.com` | API origin (point at a local dev server while developing) |
+## REST instead?
+Everything the tools do is plain HTTP — `POST https://www.snowbll.com/api/search` is live with no key. Full docs: <https://www.snowbll.com/docs>.
+## License
+MIT

package/dist/api.js CHANGED Viewed

@@ -63,6 +63,12 @@ function requireKey() {
         throw new SnowbllApiError(401, NEEDS_KEY);
     return key;
 }
+// ─── Hardware ─────────────────────────────────────────────────────────────────
+/** Save the gamer's detected rig to their account (keyed). Snowbll then flags
+ *  which games run on it — on the site and via the MCP in Claude/ChatGPT. */
+export async function saveHardware(profile) {
+    return request("/api/v1/hardware", { method: "POST", body: profile, key: requireKey() });
+}
 // ─── Catalog ────────────────────────────────────────────────────────────────
 export async function searchGames(query, limit = 5) {
     const key = getApiKey();

package/dist/bin/snowbll.js CHANGED Viewed

@@ -1,30 +1,31 @@
 #!/usr/bin/env node
 import { createInterface } from "node:readline/promises";
 import { createRequire } from "node:module";
-import { createKey, getForgeCampaign, getGame, getPersona, listForgeCampaigns, listGames, listKeys, revokeKey, searchGames, SnowbllApiError, supabaseLogin, whoami, } from "../api.js";
-import { clearConfig, getApiBase, writeConfig } from "../config.js";
+import { createKey, getForgeCampaign, getGame, getPersona, listForgeCampaigns, listGames, listKeys, revokeKey, saveHardware, searchGames, SnowbllApiError, supabaseLogin, whoami, } from "../api.js";
+import { clearConfig, getApiBase, getApiKey, writeConfig } from "../config.js";
 import { runStdioServer } from "../server.js";
 import { runSetup } from "../setup.js";
 const require = createRequire(import.meta.url);
 const { version } = require("../../package.json");
 /** The `snowbll` CLI — the live Snowbll API from your terminal. */
-const HELP = `snowbll v${version} — Snowbll from your terminal (live API: ${getApiBase()})
-Usage:
-  snowbll search "<query>" [--limit N] [--json]   Natural-language game search
-  snowbll game <id> [--json]                      One game's full metadata
-  snowbll games [--limit N] [--offset N] [--json] Plain catalog listing (key)
-  snowbll forge [id] [--status live] [--json]     Forge campaigns / one campaign
-  snowbll persona [--json]                        Your gaming persona (key)
-  snowbll whoami [--json]                         Who the configured key belongs to
-  snowbll login                                   Sign in, mint + store an API key
-  snowbll logout                                  Forget the stored key
-  snowbll keys list|create [name]|revoke <id>     Manage your API keys (sign-in)
-  snowbll setup                                   Setup wizard + agent MCP configs
-  snowbll mcp                                     Run the MCP server on stdio
-  snowbll help | --version
-Search, game, and forge work without a key; the rest use the developer-preview
+const HELP = `snowbll v${version} — Snowbll from your terminal (live API: ${getApiBase()})
+Usage:
+  snowbll search "<query>" [--limit N] [--json]   Natural-language game search
+  snowbll game <id> [--json]                      One game's full metadata
+  snowbll games [--limit N] [--offset N] [--json] Plain catalog listing (key)
+  snowbll forge [id] [--status live] [--json]     Forge campaigns / one campaign
+  snowbll persona [--json]                        Your gaming persona (key)
+  snowbll hardware                                Detect your rig → "runs on your rig" on games (key)
+  snowbll whoami [--json]                         Who the configured key belongs to
+  snowbll login                                   Sign in, mint + store an API key
+  snowbll logout                                  Forget the stored key
+  snowbll keys list|create [name]|revoke <id>     Manage your API keys (sign-in)
+  snowbll setup                                   Setup wizard + agent MCP configs
+  snowbll mcp                                     Run the MCP server on stdio
+  snowbll help | --version
+Search, game, and forge work without a key; the rest use the developer-preview
 keyed API (run \`snowbll login\` or set SNOWBLL_API_KEY). Docs: https://www.snowbll.com/docs`;
 function parseFlags(args) {
     const flags = { json: false, rest: [] };
@@ -70,6 +71,56 @@ async function promptCredentials() {
         throw new SnowbllApiError(400, "Email and password are both required.");
     return { email, password };
 }
+/** Detect this machine's rig and (when signed in) save it to the account, so
+ *  Snowbll can flag which games actually run on it. GPU model needs the
+ *  `systeminformation` package; CPU/RAM/OS come from node:os. The GPU performance
+ *  bucket is classified server-side on read, so we just send raw specs. */
+async function runHardware() {
+    const os = await import("node:os");
+    let gpuModel = null;
+    let gpuVramMb = null;
+    try {
+        const siMod = (await import("systeminformation"));
+        const si = siMod.default ?? siMod;
+        const g = await si.graphics();
+        const ctrls = (g.controllers ?? []).filter((c) => c.model);
+        const best = ctrls.sort((a, b) => (Number(b.vram) || 0) - (Number(a.vram) || 0))[0];
+        if (best) {
+            gpuModel = best.model ?? null;
+            gpuVramMb = Number(best.vram) || null;
+        }
+    }
+    catch {
+        // systeminformation missing/blocked → GPU stays null; CPU/RAM/OS still reported.
+    }
+    const cpus = os.cpus() ?? [];
+    const osLabel = { win32: "Windows", darwin: "macOS", linux: "Linux" }[os.platform()] ||
+        os.platform();
+    const profile = {
+        gpu: { raw: gpuModel, model: gpuModel, bucket: null },
+        gpuVramMb,
+        cpuModel: cpus[0]?.model?.trim() || null,
+        cpuCores: cpus.length || null,
+        ramGb: Math.round(os.totalmem() / 1e9),
+        ramCapped: false,
+        os: osLabel,
+        source: "cli",
+        detectedAt: new Date().toISOString(),
+    };
+    console.log("Detected rig:");
+    console.log(`  GPU:    ${profile.gpu.model || "(unknown — driver/systeminformation needed)"}`);
+    console.log(`  CPU:    ${profile.cpuModel || "(unknown)"} · ${profile.cpuCores ?? "?"} cores`);
+    console.log(`  Memory: ${profile.ramGb} GB`);
+    console.log(`  OS:     ${profile.os}`);
+    if (!getApiKey()) {
+        console.log("\nNot signed in — run `snowbll login` to save this to your account. " +
+            "Then Snowbll flags which games run on your rig, on the site and via the MCP.");
+        return;
+    }
+    await saveHardware(profile);
+    console.log("\nSaved to your Snowbll account. Games now show whether they run on your rig — " +
+        "on the site and via the MCP in Claude / ChatGPT.");
+}
 async function main() {
     const [command, ...args] = process.argv.slice(2);
     const flags = parseFlags(args);
@@ -105,6 +156,10 @@ async function main() {
             out(await getPersona(flags.rest[0] ?? "me"));
             return;
         }
+        case "hardware": {
+            await runHardware();
+            return;
+        }
         case "whoami": {
             out(await whoami());
             return;

package/dist/shape.js ADDED Viewed

@@ -0,0 +1,91 @@
+/**
+ * MCP game-result shape — mirrors the hosted server's mapper
+ * (Snowbll lib/v1/service.ts `toMcpGame`/`toMcpSearchResult`/`toMcpGameDetail`)
+ * so the stdio package returns the same shape regardless of which API endpoint
+ * (public or keyed v1) served the raw data. Keep in sync with the hosted mapper.
+ *
+ * Every field is sourceable from the catalog — name, link, cover, aiFit (why it
+ * matched), technicalFit (objective dims), and real Steam screenshots. Never a
+ * quality verdict, never fabricated/in-game behavior.
+ */
+export function coverImageFor(g) {
+    if (g.headerImage)
+        return g.headerImage;
+    if (g.steamAppId)
+        return `https://cdn.cloudflare.steamstatic.com/steam/apps/${g.steamAppId}/header.jpg`;
+    return null;
+}
+export function matchedTagsFor(g, c) {
+    if (!c)
+        return [];
+    const want = new Set([...(c.tags ?? []), ...(c.genres ?? []), ...(c.keywords ?? [])].map((t) => String(t).toLowerCase()));
+    return (g.gameplayTags ?? []).filter((t) => want.has(String(t).toLowerCase()));
+}
+export function toMcpGame(g, c) {
+    return {
+        id: g.id,
+        title: g.title,
+        url: g.storeUrl ?? g.itchUrl ?? g.url ?? null,
+        coverImage: coverImageFor(g),
+        technicalFit: {
+            genre: g.genre ?? null,
+            matchedTags: matchedTagsFor(g, c),
+            economyComplexity: g.economyComplexity ?? null,
+            graphicsFidelity: g.graphicsFidelity ?? null,
+            graphicsStyle: g.graphicsStyle ?? null,
+            similarTo: g.similarTo ?? [],
+            verification: g.verification ?? "unverified",
+        },
+    };
+}
+/** Normalize a search response (public or keyed) into MCP search results. */
+export function toMcpSearch(raw) {
+    const r = (raw ?? {});
+    const criteria = r.criteria;
+    const results = (r.results ?? []).map((row) => {
+        const item = (row ?? {});
+        const game = (item.game ?? item);
+        return { ...toMcpGame(game, criteria), aiFit: { score: item.score ?? 0, reasons: item.reasons ?? [] } };
+    });
+    return { query: r.query, parsedBy: r.parsedBy, criteria, results };
+}
+/** Real Steam screenshots via the store appdetails API. [] for non-Steam games,
+ *  on any error/timeout, or when none — never fabricated. */
+export async function fetchSteamScreenshots(appId) {
+    if (!appId)
+        return [];
+    try {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), 5000);
+        const res = await fetch(`https://store.steampowered.com/api/appdetails?appids=${appId}&filters=screenshots`, { signal: ctrl.signal });
+        clearTimeout(timer);
+        if (!res.ok)
+            return [];
+        const json = (await res.json());
+        const entry = json?.[String(appId)];
+        if (!entry?.success || !entry.data?.screenshots)
+            return [];
+        return entry.data.screenshots
+            .map((s) => s.path_full ?? s.path_thumbnail)
+            .filter((u) => typeof u === "string" && u.length > 0)
+            .slice(0, 8);
+    }
+    catch {
+        return [];
+    }
+}
+/** Normalize a get_game response into the MCP detail shape (+ screenshots). */
+export async function toMcpDetail(raw, includeReviews) {
+    const wrapped = (raw ?? {});
+    const g = (wrapped.game ?? wrapped);
+    const detail = {
+        ...toMcpGame(g),
+        developer: g.developer ?? null,
+        price: g.price ?? null,
+        description: g.description ?? null,
+        screenshots: await fetchSteamScreenshots(g.steamAppId),
+    };
+    if (includeReviews && g.behavioralSignals)
+        detail.behavioralSignals = g.behavioralSignals;
+    return detail;
+}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "snowbll-mcp",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Snowbll MCP server + CLI — search the Snowbll game catalog, read consented personas, and follow Forge campaigns from any MCP-capable AI agent (Claude, ChatGPT, Cursor, Hermes) or your terminal. Live API, no mock data.",
   "type": "module",
   "license": "MIT",
@@ -38,6 +38,7 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
+    "systeminformation": "^5.23.0",
     "zod": "^3.24.1"
   },
   "devDependencies": {