npm package: @modular-intelligence/eol-tracker
Description: MCP server for software end-of-life tracking via endoflife.date
Latest version: 1.0.2

# End-of-Life Tracker MCP Server

A comprehensive software end-of-life (EOL) tracking service that integrates with the endoflife.date API. This MCP (Model Context Protocol) server enables Claude to query end-of-life data for thousands of software products, including operating systems, programming languages, frameworks, and libraries.

## Overview

This server provides access to the endoflife.date API through a unified interface:

- **endoflife.date** - Comprehensive database of software lifecycle information (free, no authentication required)

Perfect for dependency management, security audits, infrastructure planning, and ensuring your software stack is current and supported.

## Tools

| Tool | Description |
|------|-------------|
| `eol_check` | Check if a specific product version is end-of-life |
| `eol_search` | Get all version lifecycle data for a product |
| `eol_upcoming` | Find product versions reaching end-of-life soon |
| `eol_all_products` | List all products tracked by endoflife.date |

### EOL Check

Check whether a specific product version is at or past its end-of-life date.

**Input Parameters:**
```typescript
{
  product: string  // Product name (e.g., 'python', 'nodejs', 'ubuntu')
  version: string  // Product version (e.g., '3.9', '18', '22.04')
}
```

**Example Request:**
```json
{
  "product": "python",
  "version": "3.8"
}
```

**Example Output:**
```json
{
  "version": "3.8",
  "eol": "2024-10-07",
  "lts": false,
  "latest": "3.8.18",
  "releaseDate": "2019-10-14",
  "support": "2021-05-03",
  "is_eol": true
}
```

### EOL Search

Retrieve comprehensive lifecycle information for all versions of a product.

**Input Parameters:**
```typescript
{
  product: string  // Product name (e.g., 'python', 'nodejs', 'ubuntu')
}
```

**Example Request:**
```json
{
  "product": "nodejs"
}
```

**Example Output:**
```json
{
  "product": "nodejs",
  "cycles": [
    {
      "cycle": "20",
      "eol": "2026-04-30",
      "lts": true,
      "latest": "20.11.0",
      "releaseDate": "2023-04-18",
      "support": "2025-10-18",
      "is_eol": false
    },
    {
      "cycle": "18",
      "eol": "2025-04-30",
      "lts": true,
      "latest": "18.19.0",
      "releaseDate": "2022-04-19",
      "support": "2024-10-18",
      "is_eol": false
    },
    {
      "cycle": "16",
      "eol": "2023-09-11",
      "lts": true,
      "latest": "16.20.2",
      "releaseDate": "2021-04-20",
      "support": "2022-10-18",
      "is_eol": true
    }
  ]
}
```

### EOL Upcoming

Find product versions that will reach end-of-life within a specified number of days.

**Input Parameters:**
```typescript
{
  product: string      // Product name (e.g., 'python', 'ubuntu')
  days_ahead: number   // Days ahead to check for upcoming EOL (1-365, default: 90)
}
```

**Example Request:**
```json
{
  "product": "ubuntu",
  "days_ahead": 365
}
```

**Example Output:**
```json
{
  "product": "ubuntu",
  "days_ahead": 365,
  "upcoming_eol": [
    {
      "version": "22.04",
      "eol": "2027-06-01",
      "lts": true,
      "latest": "22.04.3",
      "releaseDate": "2022-04-21",
      "support": "2027-01-01",
      "days_until_eol": 485
    },
    {
      "version": "23.04",
      "eol": "2024-01-20",
      "lts": false,
      "latest": "23.04",
      "releaseDate": "2023-04-20",
      "support": "2024-01-20",
      "days_until_eol": 45
    }
  ]
}
```

### EOL All Products

List all products tracked by endoflife.date, with optional filtering by name.

**Input Parameters:**
```typescript
{
  filter: string  // Optional filter to search product names (max 100 characters)
}
```

**Example Request:**
```json
{
  "filter": "python"
}
```

**Example Output:**
```json
{
  "total": 3,
  "products": [
    "python",
    "python-poetry",
    "pythonista"
  ]
}
```

## Configuration

### Environment Variables

This server requires no API keys or authentication. It connects directly to the free endoflife.date API. No environment variables are needed to run this server.

### Getting Started

The endoflife.date API is completely free and requires no registration:

**endoflife.date**
- Website: https://endoflife.date
- API Documentation: https://endoflife.date/docs/api/all
- Free tier: Unlimited queries
- Rate limit: No documented rate limit for public API
- No authentication required

## Installation

### Prerequisites

- Bun runtime (version 1.x or later)
- Node.js 18+ (alternative runtime)
- No API keys or credentials required

### Steps

1. Clone or download this repository:
```bash
git clone <repo-url>
cd eol-tracker
```

2. Install dependencies:
```bash
bun install
```

3. Build the project:
```bash
bun run build
```

4. Run the server:
```bash
bun run start
```

The server will start listening on stdio transport.

## Usage

### Running the Server

Start the server with Bun:

```bash
bun run src/index.ts
```

The server implements the Model Context Protocol (MCP) and communicates via stdio transport. It can be integrated with Claude or other MCP clients.

### Claude Desktop Configuration

Add the server to your Claude Desktop configuration at `~/Library/Application Support/Claude/claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "eol-tracker": {
      "command": "bun",
      "args": [
        "run",
        "/path/to/eol-tracker/src/index.ts"
      ]
    }
  }
}
```

### Claude Code MCP Settings

Configure the server in Claude Code's MCP settings (typically in `.mcp.json` or via settings UI):

```json
{
  "servers": {
    "eol-tracker": {
      "transport": "stdio",
      "command": "bun",
      "args": ["run", "/path/to/eol-tracker/src/index.ts"]
    }
  }
}
```

### Example Usage in Claude

Once configured, you can use the tools directly in conversations with Claude:

**Request:**
"Is Python 3.8 still supported?"

**Claude will call:**
```json
{
  "tool": "eol_check",
  "input": {
    "product": "python",
    "version": "3.8"
  }
}
```

**Request:**
"Show me all Node.js versions and their EOL dates"

**Claude will call:**
```json
{
  "tool": "eol_search",
  "input": {
    "product": "nodejs"
  }
}
```

**Request:**
"Which Ubuntu versions will reach end-of-life in the next 2 years?"

**Claude will call:**
```json
{
  "tool": "eol_upcoming",
  "input": {
    "product": "ubuntu",
    "days_ahead": 730
  }
}
```

**Request:**
"Find all Java-related products in the database"

**Claude will call:**
```json
{
  "tool": "eol_all_products",
  "input": {
    "filter": "java"
  }
}
```

## Security

This server implements comprehensive input validation to prevent injection attacks and ensure data integrity:

### Input Validation

**Product Name Validation**
- Accepts alphanumeric characters, dots, hyphens, and underscores
- Minimum length: 1 character
- Maximum length: 100 characters
- Pattern: `^[a-zA-Z0-9][a-zA-Z0-9._-]{0,100}$`
- Rejects special characters and potential path traversal attempts

**Version String Validation**
- Maximum length: 50 characters
- Blocks shell metacharacters: `;`, `&`, `|`, backticks, `$`, `()`, `{}`
- Prevents command injection via version parameters
- Accepts standard semantic versioning formats and custom version strings

**Filter String Validation**
- Maximum length: 100 characters
- Used for simple case-insensitive substring matching
- Safe for filtering product names from API responses

### What Gets Blocked

The server rejects:
- Product names with invalid characters or formats
- Version strings containing shell metacharacters
- Oversized inputs exceeding length limits
- API request failures with appropriate error messages
- Malformed or missing product/version combinations

### Error Handling

- Invalid inputs return descriptive error messages
- API errors are caught and reported with status codes
- Product/version not found errors are handled gracefully
- Network issues and timeouts are reported clearly
- All errors are returned as structured MCP error responses

## License

ISC License - see LICENSE file for details