@whoisxmlapidotcom/mcp-whoisxmlapi 1.1.0 → 1.2.0

package/README.md

@@ -1,158 +1,21 @@
-# MCP Server `mcp-whoisxmlapi`
+# @whoisxmlapidotcom/mcp-whoisxmlapi
 
-`mcp-whoisxmlapi` is a [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) server that provides AI tools access to the WhoisXMLAPI in a secure and scalable way.
-
-For full documentation, see [the MCP Server documentation](https://mcp-whoisxmlapi.pages.dev/).
-
-## Features
-
-- **Token-based Authentication**: Secure API access using bearer tokens configured via environment variables
-- **HTTP Server Mode**: Run as an HTTP server with streamable HTTP transport for web-based integrations
-- **Hosted Mode**: Multi-tenant deployment with per-request token authentication (see [HOSTING.md](HOSTING.md))
-- **Timeout Control**: Configurable request timeouts
+This package bundles the prebuilt `mcp-whoisxmlapi` binaries for all supported platforms and automatically selects the correct one for the current operating system and CPU.
 
 ## Installation
 
-### Option 1: Docker (Recommended)
-
-You can run `mcp-whoisxmlapi` directly with Docker without installing the binary:
-
-```json
-{
-  "mcpServers": {
-    "whoisxmlapi": {
-      "command": "docker",
-      "args": [
-        "run",
-        "-i",
-        "--rm",
-        "-e", "WHOISXMLAPI_TOKEN",
-        "whoisxmlapidotcom/mcp-whoisxmlapi:latest"
-        // Add custom options if needed:
-        // "--timeout=30s"
-      ],
-      "env": {
-        "WHOISXMLAPI_TOKEN": "your-api-token-here"
-      }
-    }
-  }
-}
-```
-
-### Option 2: npm
-
-Install via npm for convenience:
-
 ```bash
-# Install globally
 npm install -g @whoisxmlapidotcom/mcp-whoisxmlapi
-
-# Or install locally in your project
+# or
 npm install @whoisxmlapidotcom/mcp-whoisxmlapi
 ```
 
-#### Editor Configuration with npm
-
-If installed globally via npm:
-
-```json
-{
-  "mcpServers": {
-    "whoisxmlapi": {
-      "command": "mcp-whoisxmlapi",
-      "args": [
-        // Uncomment and modify as needed:
-        // "--timeout=30s"
-      ],
-      "env": {
-        "WHOISXMLAPI_TOKEN": "your-api-token-here"
-      }
-    }
-  }
-}
-```
-
-If installed locally in a project:
-
-```json
-{
-  "mcpServers": {
-    "whoisxmlapi": {
-      "command": "npx",
-      "args": [
-        "@whoisxmlapidotcom/mcp-whoisxmlapi"
-        // Add custom options if needed:
-        // "--timeout=30s"
-      ],
-      "env": {
-        "WHOISXMLAPI_TOKEN": "your-api-token-here"
-      }
-    }
-  }
-}
-```
-
-### Option 3: Binary Download
-
-You can also download the appropriate binary for your operating system from the [Downloads](https://mcp-whoisxmlapi.pages.dev/downloads) page and provide the full path to the binary (e.g., `/path/to/mcp-whoisxmlapi`) in your editor configuration.
-
-### Docker
-
-The MCP server is available as a Docker image using `stdio` to communicate:
-
-```bash
-docker pull whoisxmlapidotcom/mcp-whoisxmlapi:latest
-docker run --rm -e WHOISXMLAPI_TOKEN=your-token whoisxmlapidotcom/mcp-whoisxmlapi:latest
-```
-
-For SSE mode with Docker, expose the SSE port (default `3000`):
-
-```bash
-docker run --rm -p 3000:3000 -e WHOISXMLAPI_TOKEN=your-token whoisxmlapidotcom/mcp-whoisxmlapi:latest --sse --sse-port 3000
-```
-
-The configuration for SSE mode changes slightly in your editor's settings -- and note you'll need to run the Docker container in SSE mode for this to work prior to adding the configuration to your editor's or AI client settings:
-
-```json
-{
-  "mcpServers": {
-    "whoisxmlapi": {
-      "url": "http://localhost:3000"
-    }
-  }
-}
-```
-
-Do note that some MCP Clients will not support non-HTTPS endpoints.
-
-With this configuration you can use the same MCP server for multiple AI clients at once: normally, AI clients will create multiple instances of an MCP server.
+## Usage
 
-## Environment Variables
-
-- `WHOISXMLAPI_TOKEN`: Required. The API token for authenticating with the WhoisXMLAPI service.
-
-## Running Modes
-
-### Standard (stdio) Mode
-
-By default, `mcp-whoisxmlapi` runs in stdio mode, which is suitable for integration with editors and other tools that communicate via standard input/output.
-
-```bash
-export WHOISXMLAPI_TOKEN=your-token-here
-mcp-whoisxmlapi
-```
-
-### HTTP Server Mode
-
-Alternatively, you can run `mcp-whoisxmlapi` as an HTTP server for web-based integrations:
+Once installed, the CLI is available as `mcp-whoisxmlapi`. The wrapper script automatically selects the correct native binary for the current platform.
 
 ```bash
-export WHOISXMLAPI_TOKEN=your-token-here
-mcp-whoisxmlapi --http --http-port=3000
+mcp-whoisxmlapi --help
 ```
 
-In HTTP mode, the server will listen on the specified port (default: 3000) and provide the same MCP tools over HTTP using streamable HTTP transport. This is useful for web applications or environments where stdio communication isn't practical.
-
-**Available HTTP Options:**
-- `--http`: Enable HTTP server mode
-- `--http-port=PORT`: Specify the port to listen on (default: 3000)
+For configuration guides, environment variables, and tool descriptions see the public documentation at <https://mcp.whoisxmlapi.com/>.

package/bin/mcp-whoisxmlapi.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const PLATFORM_TARGETS = [
+  { platform: "darwin", arch: "x64", key: "darwin-x64" },
+  { platform: "darwin", arch: "arm64", key: "darwin-arm64" },
+  { platform: "linux", arch: "x64", key: "linux-x64" },
+  { platform: "linux", arch: "arm64", key: "linux-arm64" },
+  { platform: "linux", arch: "arm", key: "linux-arm" },
+  { platform: "win32", arch: "x64", key: "win32-x64" },
+  { platform: "win32", arch: "arm64", key: "win32-arm64" }
+];
+
+const current = PLATFORM_TARGETS.find(
+  (target) => target.platform === process.platform && target.arch === process.arch
+);
+
+if (!current) {
+  throw new Error(`Unsupported platform combination: ${process.platform}/${process.arch}`);
+}
+
+const binaryName = process.platform === "win32" ? "mcp-whoisxmlapi.exe" : "mcp-whoisxmlapi";
+const vendorRoot = path.join(__dirname, "..", "vendor", current.key);
+const binaryPath = path.join(vendorRoot, binaryName);
+
+if (!existsSync(binaryPath)) {
+  throw new Error(
+    `mcp-whoisxmlapi binary not found for ${current.key}. ` +
+      "Please reinstall the package or open an issue on GitHub."
+  );
+}
+
+const child = spawn(binaryPath, process.argv.slice(2), {
+  stdio: "inherit",
+  env: process.env
+});
+
+child.on("error", (err) => {
+  console.error(err);
+  process.exit(1);
+});
+
+child.on("exit", (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+    return;
+  }
+  process.exit(code ?? 1);
+});

package/package.json

@@ -1,45 +1,29 @@
 {
   "name": "@whoisxmlapidotcom/mcp-whoisxmlapi",
-  "version": "1.1.0",
+  "version": "1.2.0",
+  "description": "MCP server for the WhoisXML API packaged for npm.",
+  "license": "Apache-2.0",
+  "type": "module",
   "bin": {
-    "mcp-whoisxmlapi": "index.js"
+    "mcp-whoisxmlapi": "bin/mcp-whoisxmlapi.js"
   },
-  "optionalDependencies": {
-    "@whoisxmlapidotcom/mcp-whoisxmlapi_linux_arm": "1.1.0",
-    "@whoisxmlapidotcom/mcp-whoisxmlapi_linux_amd64": "1.1.0",
-    "@whoisxmlapidotcom/mcp-whoisxmlapi_linux_arm64": "1.1.0",
-    "@whoisxmlapidotcom/mcp-whoisxmlapi_windows_amd64": "1.1.0",
-    "@whoisxmlapidotcom/mcp-whoisxmlapi_windows_arm": "1.1.0",
-    "@whoisxmlapidotcom/mcp-whoisxmlapi_windows_arm64": "1.1.0",
-    "@whoisxmlapidotcom/mcp-whoisxmlapi_darwin_amd64": "1.1.0",
-    "@whoisxmlapidotcom/mcp-whoisxmlapi_darwin_arm64": "1.1.0"
-  },
-  "os": [
-    "linux",
-    "win32",
-    "darwin"
-  ],
-  "cpu": [
-    "arm",
-    "x64",
-    "arm64"
-  ],
   "files": [
-    "README.md"
+    "bin",
+    "vendor",
+    "README.md",
+    "LICENSE"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/whois-api-llc/mcp-whoisxmlapi"
+  },
   "keywords": [
     "mcp",
-    "mcp-server",
     "whoisxmlapi",
-    "whois",
-    "reverse-dns",
-    "reverse-whois",
-    "ip-geolocation",
-    "ip-whois",
-    "domain-whois",
-    "domain-availability",
-    "domain-search",
-    "domain-status"
+    "model-context-protocol",
+    "mcp-server"
   ],
-  "description": "A MCP server for the WhoisXML API"
-}
+  "engines": {
+    "node": ">=18"
+  }
+}

package/index.js

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-const path = require('path');
-const child_process = require('child_process');
-const mapping = { linux_arm: { name: [ '@whoisxmlapidotcom', 'mcp-whoisxmlapi_linux_arm' ], bin: 'mcp-whoisxmlapi' }, linux_x64: { name: [ '@whoisxmlapidotcom', 'mcp-whoisxmlapi_linux_amd64' ], bin: 'mcp-whoisxmlapi' }, linux_arm64: { name: [ '@whoisxmlapidotcom', 'mcp-whoisxmlapi_linux_arm64' ], bin: 'mcp-whoisxmlapi' }, win32_x64: { name: [ '@whoisxmlapidotcom', 'mcp-whoisxmlapi_windows_amd64' ], bin: 'mcp-whoisxmlapi.exe' }, win32_arm: { name: [ '@whoisxmlapidotcom', 'mcp-whoisxmlapi_windows_arm' ], bin: 'mcp-whoisxmlapi.exe' }, win32_arm64: { name: [ '@whoisxmlapidotcom', 'mcp-whoisxmlapi_windows_arm64' ], bin: 'mcp-whoisxmlapi.exe' }, darwin_x64: { name: [ '@whoisxmlapidotcom', 'mcp-whoisxmlapi_darwin_amd64' ], bin: 'mcp-whoisxmlapi' }, darwin_arm64: { name: [ '@whoisxmlapidotcom', 'mcp-whoisxmlapi_darwin_arm64' ], bin: 'mcp-whoisxmlapi' } };
-const definition = mapping[process.platform + '_' + process.arch];
-const packageJsonPath = require.resolve(path.join(...definition.name, 'package.json'));
-const packagePath = path.join(path.dirname(packageJsonPath), definition.bin);
-child_process.spawn(packagePath, process.argv.splice(2), {
-  stdio: 'inherit',
-  env: process.env,
-});