oremus-web-search 0.1.3

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Oremus Labs
+
+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

@@ -0,0 +1,204 @@
+# oremus-web-search
+
+An MCP server that exposes:
+
+- `web_search`: web search via a configurable SearXNG instance (JSON API).
+- `fetch_and_extract`: main-content extraction via a configurable Trafilatura MCP server (Streamable HTTP).
+- `rotate_vpn`: asks Trafilatura to rotate its VPN/proxy egress.
+
+This is designed to be run with `npx` as an MCP server (stdio transport).
+
+## Why this exists
+
+- SearXNG is great for finding URLs.
+- Trafilatura is great at extracting clean article text and metadata.
+- This server provides a single MCP endpoint that combines both.
+
+## Install / Run
+
+### Option A (recommended): no-token install via GitHub Release tarball
+
+This avoids GitHub Packages auth requirements and “just works” with `npx`:
+
+```bash
+SEARXNG_URL="https://search.oremuslabs.app" \\
+TRAFILATURA_MCP_URL="https://trafilatura.oremuslabs.app/mcp" \\
+npx -y https://github.com/Oremus-Labs/web-search-mcp/releases/latest/download/web-search-mcp.tgz
+```
+
+If you want a pinned version, use the versioned asset under the tag, e.g.:
+
+```bash
+npx -y https://github.com/Oremus-Labs/web-search-mcp/releases/download/v0.1.1/oremus-labs-web-search-mcp-0.1.1.tgz
+```
+
+### Option B: npm (no token required)
+
+Once published to the public npm registry, this should work without any auth:
+
+```bash
+SEARXNG_URL="https://search.oremuslabs.app" \\
+TRAFILATURA_MCP_URL="https://trafilatura.oremuslabs.app/mcp" \\
+npx -y oremus-web-search
+```
+
+### Option C: GitHub Packages
+
+GitHub Packages’ npm registry typically requires authentication (`read:packages`) to install.
+
+## Configuration
+
+Required environment variables:
+
+- `SEARXNG_URL`
+  - Base URL for your SearXNG instance.
+  - The server calls `${SEARXNG_URL}/search?format=json&...`.
+  - You may also set `SEARXNG_URL` to the full `/search` endpoint.
+- `TRAFILATURA_MCP_URL`
+  - Full MCP endpoint URL for Trafilatura (must include the MCP path), e.g. `http://...:8090/mcp`.
+
+Optional environment variables:
+
+- `USER_AGENT` (default: `oremus-web-search`)
+- `TRAFILATURA_BEARER_TOKEN` (adds `Authorization: Bearer ...` when calling Trafilatura MCP)
+
+## Tools
+
+### `web_search`
+
+Input (matches the common SearXNG MCP shape):
+
+- `query` (string, required)
+- `pageno` (number, optional)
+- `time_range` (`day|month|year`, optional)
+- `language` (string, optional)
+- `safesearch` (`0|1|2`, optional)
+
+Output:
+
+- A single `text` block formatted as:
+  - `Title: ...`
+  - `Description: ...`
+  - `URL: ...`
+  - `Relevance Score: ...`
+
+### `fetch_and_extract`
+
+Input:
+
+- `url` (string, required)
+- `include_comments` (boolean, optional)
+- `include_tables` (boolean, optional)
+- `use_proxy` (boolean, optional)
+
+Output:
+
+- Pass-through of the Trafilatura MCP server tool result (typically a single `text` block containing JSON).
+
+### `rotate_vpn`
+
+Input:
+
+- none
+
+Output:
+
+- Pass-through of the Trafilatura MCP server tool result.
+
+Notes:
+
+- This tool is intentionally exposed through Trafilatura (in-cluster) so you don't need to expose a public REST endpoint for VPN rotation.
+- Rotation is disruptive to in-flight requests; only call it when you’re getting blocked/rate-limited.
+
+## Local development
+
+```bash
+cd web-search-mcp
+npm install
+npm run build
+SEARXNG_URL="http://127.0.0.1:18080" TRAFILATURA_MCP_URL="http://127.0.0.1:18090/mcp" npm run inspector
+```
+
+## Kubernetes access (typical)
+
+If your Trafilatura MCP server is only exposed as an in-cluster Service, run it through a port-forward:
+
+```bash
+kubectl -n searxng port-forward svc/searxng-trafilatura-mcp 18090:8090
+```
+
+Then set:
+
+- `TRAFILATURA_MCP_URL=http://127.0.0.1:18090/mcp`
+
+## Use in Codex CLI
+
+Add a server entry to `~/.codex/config.toml`:
+
+```toml
+[mcp_servers.web_search]
+command = "npx"
+args = ["-y", "https://github.com/Oremus-Labs/web-search-mcp/releases/latest/download/web-search-mcp.tgz"]
+env = { "SEARXNG_URL" = "https://search.oremuslabs.app", "TRAFILATURA_MCP_URL" = "https://trafilatura.oremuslabs.app/mcp" }
+startup_timeout_sec = 30
+tool_timeout_sec = 120
+```
+
+If you published to npm and want the simplest setup:
+
+```toml
+[mcp_servers.web_search]
+command = "npx"
+args = ["-y", "oremus-web-search"]
+env = { "SEARXNG_URL" = "https://search.oremuslabs.app", "TRAFILATURA_MCP_URL" = "https://trafilatura.oremuslabs.app/mcp" }
+startup_timeout_sec = 30
+tool_timeout_sec = 120
+```
+
+Restart Codex CLI after editing.
+
+## Use in Claude Code
+
+Add a server entry to your Claude Code MCP config (commonly `.mcp.json` in your project root, or wherever you keep your Claude configuration):
+
+### Option A (Release tarball)
+
+```json
+{
+  "mcpServers": {
+    "web-search": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "https://github.com/Oremus-Labs/web-search-mcp/releases/latest/download/web-search-mcp.tgz"
+      ],
+      "env": {
+        "SEARXNG_URL": "https://search.oremuslabs.app",
+        "TRAFILATURA_MCP_URL": "https://trafilatura.oremuslabs.app/mcp"
+      }
+    }
+  }
+}
+```
+
+### Option B (npm)
+
+```json
+{
+  "mcpServers": {
+    "web-search": {
+      "command": "npx",
+      "args": ["-y", "oremus-web-search"],
+      "env": {
+        "SEARXNG_URL": "https://search.oremuslabs.app",
+        "TRAFILATURA_MCP_URL": "https://trafilatura.oremuslabs.app/mcp"
+      }
+    }
+  }
+}
+```
+
+## Notes
+
+- This server uses stdio transport (default) so it works with MCP clients that launch subprocesses.
+- Trafilatura is called through its MCP Streamable HTTP endpoint; this repo’s Kubernetes deployment exposes it as `svc/searxng-trafilatura-mcp` in namespace `searxng`.

package/dist/config.js

@@ -0,0 +1,23 @@
+export function loadConfig(env) {
+    const searxngUrl = (env.SEARXNG_URL || "").trim();
+    const trafilaturaMcpUrl = (env.TRAFILATURA_MCP_URL || "").trim();
+    if (!searxngUrl) {
+        throw new Error("Missing required env var: SEARXNG_URL");
+    }
+    if (!trafilaturaMcpUrl) {
+        throw new Error("Missing required env var: TRAFILATURA_MCP_URL");
+    }
+    return {
+        searxngUrl,
+        searxngUserAgent: (env.USER_AGENT || "oremus-web-search").trim(),
+        trafilaturaMcpUrl,
+        trafilaturaBearerToken: (env.TRAFILATURA_BEARER_TOKEN || "").trim() || undefined,
+    };
+}
+export function normalizeSearxngSearchEndpoint(searxngUrl) {
+    const trimmed = searxngUrl.replace(/\/+$/, "");
+    if (trimmed.endsWith("/search")) {
+        return trimmed;
+    }
+    return `${trimmed}/search`;
+}

package/dist/index.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { loadConfig } from "./config.js";
+import { StreamableHttpMcpClient } from "./streamableHttpMcpClient.js";
+import { webSearch } from "./searxng.js";
+import { FETCH_AND_EXTRACT_TOOL, ROTATE_VPN_TOOL, WEB_SEARCH_TOOL, isFetchAndExtractArgs, isRotateVpnArgs, isWebSearchArgs, } from "./types.js";
+import { createConfigResource, createHelpResource } from "./resources.js";
+const packageVersion = "0.1.3";
+async function main() {
+    const config = loadConfig(process.env);
+    const trafilaturaClient = new StreamableHttpMcpClient({
+        url: config.trafilaturaMcpUrl,
+        bearerToken: config.trafilaturaBearerToken,
+    });
+    const server = new Server({ name: "oremus-web-search", version: packageVersion }, {
+        capabilities: {
+            logging: {},
+            resources: {},
+            tools: { listChanged: false },
+        },
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return { tools: [WEB_SEARCH_TOOL, FETCH_AND_EXTRACT_TOOL, ROTATE_VPN_TOOL] };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        if (name === "web_search") {
+            if (!isWebSearchArgs(args))
+                throw new Error("Invalid arguments for web_search");
+            const result = await webSearch(config.searxngUrl, config.searxngUserAgent, args);
+            return { content: [{ type: "text", text: result }] };
+        }
+        if (name === "fetch_and_extract") {
+            if (!isFetchAndExtractArgs(args))
+                throw new Error("Invalid arguments for fetch_and_extract");
+            const result = await trafilaturaClient.callTool("fetch_and_extract", {
+                url: args.url,
+                include_comments: args.include_comments ?? false,
+                include_tables: args.include_tables ?? false,
+                use_proxy: args.use_proxy ?? true,
+            });
+            return { content: result.content };
+        }
+        if (name === "rotate_vpn") {
+            if (!isRotateVpnArgs(args))
+                throw new Error("Invalid arguments for rotate_vpn");
+            const result = await trafilaturaClient.callTool("rotate_vpn", {});
+            return { content: result.content };
+        }
+        throw new Error(`Unknown tool: ${name}`);
+    });
+    server.setRequestHandler(ListResourcesRequestSchema, async () => {
+        return {
+            resources: [
+                {
+                    uri: "config://server-config",
+                    mimeType: "application/json",
+                    name: "Server Configuration",
+                    description: "Current server configuration and environment variables",
+                },
+                {
+                    uri: "help://usage-guide",
+                    mimeType: "text/markdown",
+                    name: "Usage Guide",
+                    description: "How to use this server effectively",
+                },
+            ],
+        };
+    });
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        const { uri } = request.params;
+        if (uri === "config://server-config") {
+            return {
+                contents: [{ uri, mimeType: "application/json", text: createConfigResource(config) }],
+            };
+        }
+        if (uri === "help://usage-guide") {
+            return {
+                contents: [{ uri, mimeType: "text/markdown", text: createHelpResource() }],
+            };
+        }
+        throw new Error(`Unknown resource: ${uri}`);
+    });
+    if (process.stdin.isTTY) {
+        console.log(`oremus-web-search v${packageVersion} - Ready`);
+        console.log(`SearXNG URL: ${config.searxngUrl}`);
+        console.log(`Trafilatura MCP URL: ${config.trafilaturaMcpUrl}`);
+        console.log("Waiting for MCP client connection via STDIO...\n");
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+process.on("uncaughtException", (error) => {
+    console.error("Uncaught Exception:", error);
+    process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+    console.error("Unhandled Rejection:", reason);
+    process.exit(1);
+});
+main().catch((error) => {
+    console.error("Failed to start server:", error);
+    process.exit(1);
+});

package/dist/resources.js

@@ -0,0 +1,28 @@
+export function createConfigResource(config) {
+    return JSON.stringify({
+        searxngUrl: config.searxngUrl,
+        searxngUserAgent: config.searxngUserAgent,
+        trafilaturaMcpUrl: config.trafilaturaMcpUrl,
+        trafilaturaBearerTokenConfigured: Boolean(config.trafilaturaBearerToken),
+    }, null, 2);
+}
+export function createHelpResource() {
+    return `# oremus-web-search
+
+This MCP server exposes tools:
+
+- \`web_search\` → calls the configured SearXNG instance JSON API.
+- \`fetch_and_extract\` → delegates to the configured Trafilatura MCP server (Streamable HTTP).
+- \`rotate_vpn\` → asks Trafilatura to rotate its VPN/proxy egress.
+
+## Required environment variables
+
+- \`SEARXNG_URL\`: Base URL of your SearXNG instance (e.g. \`https://search.oremuslabs.app\`).
+- \`TRAFILATURA_MCP_URL\`: MCP endpoint URL for Trafilatura (must include the MCP path, e.g. \`http://...:8090/mcp\`).
+
+## Optional environment variables
+
+- \`USER_AGENT\`: User-Agent string for SearXNG HTTP requests.
+- \`TRAFILATURA_BEARER_TOKEN\`: If your Trafilatura MCP endpoint requires Authorization.
+`;
+}

package/dist/searxng.js

@@ -0,0 +1,48 @@
+import { normalizeSearxngSearchEndpoint } from "./config.js";
+function formatResults(results) {
+    return results
+        .map((r) => {
+        const title = r.title ?? "";
+        const description = r.content ?? "";
+        const url = r.url ?? "";
+        const score = typeof r.score === "number" ? r.score.toFixed(3) : r.score ?? "";
+        return [
+            `Title: ${title}`,
+            `Description: ${description}`,
+            `URL: ${url}`,
+            `Relevance Score: ${score}`,
+        ].join("\n");
+    })
+        .join("\n\n");
+}
+export async function webSearch(searxngUrl, userAgent, args) {
+    const endpoint = normalizeSearxngSearchEndpoint(searxngUrl);
+    const url = new URL(endpoint);
+    url.searchParams.set("q", args.query);
+    url.searchParams.set("format", "json");
+    if (args.pageno !== undefined)
+        url.searchParams.set("pageno", String(args.pageno));
+    if (args.time_range)
+        url.searchParams.set("time_range", args.time_range);
+    if (args.language)
+        url.searchParams.set("language", args.language);
+    if (args.safesearch)
+        url.searchParams.set("safesearch", args.safesearch);
+    const resp = await fetch(url.toString(), {
+        method: "GET",
+        headers: {
+            "User-Agent": userAgent,
+            Accept: "application/json",
+        },
+    });
+    if (!resp.ok) {
+        const text = await resp.text().catch(() => "");
+        throw new Error(`SearXNG HTTP ${resp.status}: ${text.slice(0, 500)}`);
+    }
+    const data = (await resp.json());
+    const results = data.results ?? [];
+    if (!results.length) {
+        return "No results.";
+    }
+    return formatResults(results);
+}

package/dist/streamableHttpMcpClient.js

@@ -0,0 +1,157 @@
+function contentTypeBase(value) {
+    if (!value)
+        return "";
+    return value.split(";")[0]?.trim().toLowerCase() ?? "";
+}
+async function readAllText(stream) {
+    if (!stream)
+        return "";
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let out = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        out += decoder.decode(value, { stream: true });
+    }
+    out += decoder.decode();
+    return out;
+}
+function parseSseMessages(sseText) {
+    const events = sseText.split(/\r?\n\r?\n/).map((e) => e.trim()).filter(Boolean);
+    const messages = [];
+    for (const event of events) {
+        const lines = event.split(/\r?\n/);
+        for (const line of lines) {
+            if (line.startsWith("data:")) {
+                const data = line.slice("data:".length).trim();
+                if (data)
+                    messages.push(data);
+            }
+        }
+    }
+    return messages;
+}
+export class StreamableHttpMcpClient {
+    url;
+    authorization;
+    sessionId;
+    protocolVersion;
+    nextId = 1;
+    initializing;
+    constructor(options) {
+        this.url = options.url;
+        this.authorization = options.bearerToken ? `Bearer ${options.bearerToken}` : undefined;
+    }
+    headers(extra) {
+        const headers = {
+            Accept: "application/json, text/event-stream",
+            "Content-Type": "application/json",
+            ...(extra ?? {}),
+        };
+        if (this.authorization)
+            headers.Authorization = this.authorization;
+        if (this.sessionId)
+            headers["mcp-session-id"] = this.sessionId;
+        if (this.protocolVersion)
+            headers["mcp-protocol-version"] = this.protocolVersion;
+        return headers;
+    }
+    async post(message) {
+        const resp = await fetch(this.url, {
+            method: "POST",
+            headers: this.headers(),
+            body: JSON.stringify(message),
+        });
+        const newSessionId = resp.headers.get("mcp-session-id");
+        if (newSessionId)
+            this.sessionId = newSessionId;
+        const ct = contentTypeBase(resp.headers.get("content-type"));
+        if (resp.status >= 400) {
+            const body = await resp.text().catch(() => "");
+            throw new Error(`MCP HTTP ${resp.status}: ${body.slice(0, 500)}`);
+        }
+        // Notifications often return 202 with no body.
+        if (!("id" in message)) {
+            return null;
+        }
+        if (ct === "application/json") {
+            return (await resp.json());
+        }
+        if (ct === "text/event-stream") {
+            const sseText = await readAllText(resp.body);
+            const datas = parseSseMessages(sseText);
+            for (const data of datas) {
+                try {
+                    const parsed = JSON.parse(data);
+                    if (parsed && parsed.id === message.id) {
+                        return parsed;
+                    }
+                }
+                catch {
+                    // ignore malformed lines
+                }
+            }
+            throw new Error("MCP SSE response did not include a matching JSON-RPC response");
+        }
+        const body = await resp.text().catch(() => "");
+        throw new Error(`Unexpected MCP response content-type '${ct}': ${body.slice(0, 200)}`);
+    }
+    async ensureInitialized() {
+        if (this.initializing)
+            return this.initializing;
+        if (this.sessionId && this.protocolVersion)
+            return;
+        this.initializing = (async () => {
+            const initId = this.nextId++;
+            const initReq = {
+                jsonrpc: "2.0",
+                id: initId,
+                method: "initialize",
+                params: {
+                    protocolVersion: "2025-11-25",
+                    capabilities: {},
+                    clientInfo: { name: "oremus-web-search", version: "0.1.3" },
+                },
+            };
+            const initResp = await this.post(initReq);
+            if (!initResp)
+                throw new Error("Initialize returned no response");
+            if (initResp.error)
+                throw new Error(`Initialize error: ${initResp.error.message}`);
+            const result = initResp.result;
+            const negotiated = result?.protocolVersion;
+            if (typeof negotiated === "string")
+                this.protocolVersion = negotiated;
+            const initialized = {
+                jsonrpc: "2.0",
+                method: "notifications/initialized",
+                params: {},
+            };
+            await this.post(initialized);
+        })().finally(() => {
+            this.initializing = undefined;
+        });
+        return this.initializing;
+    }
+    async callTool(name, args) {
+        await this.ensureInitialized();
+        const id = this.nextId++;
+        const req = {
+            jsonrpc: "2.0",
+            id,
+            method: "tools/call",
+            params: {
+                name,
+                arguments: args,
+            },
+        };
+        const resp = await this.post(req);
+        if (!resp)
+            throw new Error("tools/call returned no response");
+        if (resp.error)
+            throw new Error(`tools/call error: ${resp.error.message}`);
+        return resp.result;
+    }
+}

package/dist/types.js

@@ -0,0 +1,85 @@
+export function isWebSearchArgs(args) {
+    return (typeof args === "object" &&
+        args !== null &&
+        "query" in args &&
+        typeof args.query === "string");
+}
+export const WEB_SEARCH_TOOL = {
+    name: "web_search",
+    description: "Performs a web search using a SearXNG instance. Returns a formatted text block similar to `searxng_web_search`.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "The search query.",
+            },
+            pageno: {
+                type: "number",
+                description: "Search page number (starts at 1).",
+                default: 1,
+            },
+            time_range: {
+                type: "string",
+                description: "Time range of search (day, month, year).",
+                enum: ["day", "month", "year"],
+            },
+            language: {
+                type: "string",
+                description: "Language code for search results (e.g., 'en', 'fr', 'de'). Default is instance-dependent.",
+                default: "all",
+            },
+            safesearch: {
+                type: "string",
+                description: "Safe search filter level (0: None, 1: Moderate, 2: Strict).",
+                enum: ["0", "1", "2"],
+                default: "0",
+            },
+        },
+        required: ["query"],
+    },
+};
+export function isFetchAndExtractArgs(args) {
+    return (typeof args === "object" &&
+        args !== null &&
+        "url" in args &&
+        typeof args.url === "string");
+}
+export const FETCH_AND_EXTRACT_TOOL = {
+    name: "fetch_and_extract",
+    description: "Fetches a URL and extracts the main content and metadata using the configured Trafilatura MCP server.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            url: { type: "string", description: "The URL of the page to extract." },
+            include_comments: {
+                type: "boolean",
+                description: "Whether to include comment sections at the bottom of articles.",
+                default: false,
+            },
+            include_tables: {
+                type: "boolean",
+                description: "Extract text from HTML <table> elements.",
+                default: false,
+            },
+            use_proxy: {
+                type: "boolean",
+                description: "Whether the Trafilatura service should route via its proxy pool.",
+                default: true,
+            },
+        },
+        required: ["url"],
+    },
+};
+export function isRotateVpnArgs(args) {
+    return args === undefined || (typeof args === "object" && args !== null);
+}
+export const ROTATE_VPN_TOOL = {
+    name: "rotate_vpn",
+    description: "Requests the Trafilatura service to rotate its VPN/proxy egress (useful when rate-limited).",
+    inputSchema: {
+        type: "object",
+        properties: {},
+        additionalProperties: false,
+    },
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "oremus-web-search",
+  "version": "0.1.3",
+  "description": "MCP server that combines SearXNG web search with Trafilatura extraction",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/Oremus-Labs/web-search-mcp.git"
+  },
+  "homepage": "https://github.com/Oremus-Labs/web-search-mcp",
+  "bugs": {
+    "url": "https://github.com/Oremus-Labs/web-search-mcp/issues"
+  },
+  "bin": {
+    "oremus-web-search": "dist/index.js"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc && shx chmod +x dist/*.js",
+    "clean": "shx rm -rf dist",
+    "dev": "tsx src/index.ts",
+    "inspector": "npx @modelcontextprotocol/inspector node dist/index.js",
+    "prepack": "npm run clean && npm run build",
+    "smoke": "tsx scripts/smoke.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.25.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.17.2",
+    "shx": "^0.4.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.8.3"
+  }
+}