@lvnt/release-radar 1.0.0

package/.env.example

@@ -0,0 +1,2 @@
+TELEGRAM_BOT_TOKEN=your_bot_token_here
+TELEGRAM_CHAT_ID=your_chat_id_here

package/README.md

@@ -0,0 +1,188 @@
+# ReleaseRadar
+
+A Node.js service that monitors tool/software versions and sends Telegram notifications when updates are detected.
+
+Built for environments with limited internet access (e.g., intranet) where manual version checking is tedious.
+
+## Features
+
+- Monitors 15+ tools from various sources:
+  - GitHub Releases
+  - npm Registry
+  - VS Code Marketplace
+  - Custom APIs (VSCode, Claude Code CLI, CMake)
+- Sends Telegram notifications on version changes
+- Batched notifications (multiple updates in one message)
+- Periodic checks via cron (configurable interval)
+- Manual check via Telegram `/check` command
+- Persistent version storage (survives restarts)
+
+## Tracked Tools
+
+| Tool | Source |
+|------|--------|
+| VSCode | VS Code Update API |
+| Claude Code CLI | Google Storage / GitHub |
+| Ninja | GitHub |
+| CMake | cmake.org |
+| Git | GitHub (git-for-windows) |
+| Clangd | GitHub |
+| Wezterm | GitHub |
+| Ralphy | npm |
+| vscode-cpptools | GitHub |
+| vscode-clangd | GitHub |
+| Claude Code VSCode | VS Code Marketplace |
+| CMake Tools | GitHub |
+| Roo Code | GitHub |
+| Atlascode | GitHub |
+| Zed | GitHub |
+
+## Prerequisites
+
+- Node.js 18+
+- Telegram Bot Token (from [@BotFather](https://t.me/botfather))
+- Telegram Chat ID (your user ID or group ID)
+
+## Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/lvntbkdmr/release-radar.git
+cd release-radar
+
+# Install dependencies
+npm install
+
+# Configure environment
+cp .env.example .env
+# Edit .env with your Telegram credentials
+
+# Build
+npm run build
+```
+
+## Configuration
+
+### Environment Variables
+
+Create a `.env` file:
+
+```env
+TELEGRAM_BOT_TOKEN=your_bot_token_here
+TELEGRAM_CHAT_ID=your_chat_id_here
+```
+
+### Tools Configuration
+
+Edit `config/tools.json` to add/remove tools:
+
+```json
+{
+  "checkIntervalHours": 6,
+  "tools": [
+    {
+      "name": "MyTool",
+      "type": "github",
+      "repo": "owner/repo"
+    }
+  ]
+}
+```
+
+#### Tool Types
+
+| Type | Required Fields | Description |
+|------|-----------------|-------------|
+| `github` | `repo` | GitHub releases (e.g., `"owner/repo"`) |
+| `npm` | `package` | npm registry package |
+| `vscode-marketplace` | `extensionId` | VS Code extension (e.g., `"publisher.extension"`) |
+| `custom` | `customFetcher` | Built-in fetchers: `vscode`, `claude-cli`, `cmake` |
+
+## Usage
+
+### Development
+```bash
+npm run dev
+```
+
+### Production
+```bash
+npm run build
+npm start
+```
+
+### With pm2 (recommended)
+```bash
+npm install -g pm2
+pm2 start npm --name "release-radar" -- start
+pm2 save
+```
+
+### Telegram Commands
+
+| Command | Description |
+|---------|-------------|
+| `/check` | Manually trigger version check |
+| `/status` | Show all tracked versions |
+| `/interval` | Show current check interval |
+| `/setinterval <hours>` | Set check interval (1-24 hours) |
+
+## Project Structure
+
+```
+release-radar/
+├── src/
+│   ├── index.ts          # Main entry point
+│   ├── checker.ts        # Version check orchestration
+│   ├── storage.ts        # JSON persistence
+│   ├── notifier.ts       # Telegram notifications
+│   ├── types.ts          # TypeScript interfaces
+│   └── fetchers/
+│       ├── index.ts      # Fetcher registry
+│       ├── github-release.ts
+│       ├── npm.ts
+│       ├── vscode-marketplace.ts
+│       └── custom.ts
+├── config/
+│   └── tools.json        # Tool configuration
+├── data/
+│   └── versions.json     # Persisted version state
+├── docs/
+│   └── OPERATIONS.md     # Operations guide
+└── dist/                 # Compiled JavaScript
+```
+
+## Testing
+
+```bash
+# Run all tests
+npm test
+
+# Watch mode
+npm run test:watch
+```
+
+## Notifications
+
+### Version Update
+```
+🔄 Ninja: 1.11.1 → 1.12.0
+🔄 Git: 2.43.0 → 2.44.0
+```
+
+### Fetch Failure
+```
+⚠️ Failed to check CMake: Request timeout
+```
+
+## Operations
+
+See [docs/OPERATIONS.md](docs/OPERATIONS.md) for detailed instructions on:
+- Starting/stopping the service
+- Viewing logs
+- Auto-start configuration
+- Troubleshooting
+
+## License
+
+ISC

package/bin/release-radar.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync, mkdirSync, copyFileSync } from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageRoot = join(__dirname, '..');
+
+// Ensure config directory exists in current working directory
+const configDir = join(process.cwd(), 'config');
+const dataDir = join(process.cwd(), 'data');
+
+if (!existsSync(configDir)) {
+  mkdirSync(configDir, { recursive: true });
+  // Copy default config
+  const defaultConfig = join(packageRoot, 'config', 'tools.json');
+  if (existsSync(defaultConfig)) {
+    copyFileSync(defaultConfig, join(configDir, 'tools.json'));
+    console.log('Created config/tools.json with default configuration');
+  }
+}
+
+if (!existsSync(dataDir)) {
+  mkdirSync(dataDir, { recursive: true });
+}
+
+// Check for .env file
+const envFile = join(process.cwd(), '.env');
+if (!existsSync(envFile)) {
+  const envExample = join(packageRoot, '.env.example');
+  if (existsSync(envExample)) {
+    copyFileSync(envExample, envFile);
+    console.log('Created .env file - please edit with your Telegram credentials');
+    console.log('  TELEGRAM_BOT_TOKEN=your_bot_token_here');
+    console.log('  TELEGRAM_CHAT_ID=your_chat_id_here');
+    process.exit(1);
+  }
+}
+
+// Run the main application
+import('../dist/index.js');

package/config/tools.json

@@ -0,0 +1,80 @@
+{
+  "checkIntervalHours": 1,
+  "tools": [
+    {
+      "name": "VSCode",
+      "type": "custom",
+      "customFetcher": "vscode"
+    },
+    {
+      "name": "Claude Code CLI",
+      "type": "custom",
+      "customFetcher": "claude-cli"
+    },
+    {
+      "name": "Ninja",
+      "type": "github",
+      "repo": "ninja-build/ninja"
+    },
+    {
+      "name": "CMake",
+      "type": "custom",
+      "customFetcher": "cmake"
+    },
+    {
+      "name": "Git",
+      "type": "github",
+      "repo": "git-for-windows/git"
+    },
+    {
+      "name": "Clangd",
+      "type": "github",
+      "repo": "clangd/clangd"
+    },
+    {
+      "name": "Wezterm",
+      "type": "github",
+      "repo": "wezterm/wezterm"
+    },
+    {
+      "name": "Ralphy",
+      "type": "npm",
+      "package": "ralphy-cli"
+    },
+    {
+      "name": "vscode-cpptools",
+      "type": "github",
+      "repo": "microsoft/vscode-cpptools"
+    },
+    {
+      "name": "vscode-clangd",
+      "type": "github",
+      "repo": "clangd/vscode-clangd"
+    },
+    {
+      "name": "Claude Code VSCode",
+      "type": "vscode-marketplace",
+      "extensionId": "anthropic.claude-code"
+    },
+    {
+      "name": "CMake Tools",
+      "type": "github",
+      "repo": "microsoft/vscode-cmake-tools"
+    },
+    {
+      "name": "Roo Code",
+      "type": "github",
+      "repo": "RooCodeInc/Roo-Code"
+    },
+    {
+      "name": "Atlascode",
+      "type": "github",
+      "repo": "atlassian/atlascode"
+    },
+    {
+      "name": "Zed",
+      "type": "github",
+      "repo": "zed-industries/zed"
+    }
+  ]
+}

package/dist/checker.d.ts

@@ -0,0 +1,10 @@
+import type { ToolConfig } from './types.js';
+import type { Storage } from './storage.js';
+import type { Notifier } from './notifier.js';
+export declare class Checker {
+    private tools;
+    private storage;
+    private notifier;
+    constructor(tools: ToolConfig[], storage: Storage, notifier: Notifier);
+    checkAll(): Promise<void>;
+}

package/dist/checker.js

@@ -0,0 +1,35 @@
+import { fetchVersion } from './fetchers/index.js';
+export class Checker {
+    tools;
+    storage;
+    notifier;
+    constructor(tools, storage, notifier) {
+        this.tools = tools;
+        this.storage = storage;
+        this.notifier = notifier;
+    }
+    async checkAll() {
+        const updates = [];
+        const failures = [];
+        for (const tool of this.tools) {
+            try {
+                const newVersion = await fetchVersion(tool);
+                const oldVersion = this.storage.getVersion(tool.name);
+                if (oldVersion === null) {
+                    // First run - store without notifying
+                    this.storage.setVersion(tool.name, newVersion);
+                }
+                else if (oldVersion !== newVersion) {
+                    updates.push({ name: tool.name, oldVersion, newVersion });
+                    this.storage.setVersion(tool.name, newVersion);
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                failures.push({ name: tool.name, error: message });
+            }
+        }
+        await this.notifier.sendBatchedUpdates(updates);
+        await this.notifier.sendBatchedFailures(failures);
+    }
+}

package/dist/checker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/checker.test.js

@@ -0,0 +1,64 @@
+// src/checker.test.ts
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Checker } from './checker.js';
+vi.mock('./fetchers/index.js', () => ({
+    fetchVersion: vi.fn()
+}));
+import { fetchVersion } from './fetchers/index.js';
+describe('Checker', () => {
+    let mockStorage;
+    let mockNotifier;
+    let checker;
+    let tools;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockStorage = {
+            getVersion: vi.fn(),
+            setVersion: vi.fn()
+        };
+        mockNotifier = {
+            sendBatchedUpdates: vi.fn().mockResolvedValue(undefined),
+            sendBatchedFailures: vi.fn().mockResolvedValue(undefined)
+        };
+        tools = [
+            { name: 'Ninja', type: 'github', repo: 'ninja-build/ninja' },
+            { name: 'Git', type: 'github', repo: 'git-for-windows/git' }
+        ];
+        checker = new Checker(tools, mockStorage, mockNotifier);
+    });
+    it('notifies on version change', async () => {
+        mockStorage.getVersion.mockReturnValueOnce('1.11.1').mockReturnValueOnce('2.43.0');
+        vi.mocked(fetchVersion)
+            .mockResolvedValueOnce('1.12.0')
+            .mockResolvedValueOnce('2.43.0');
+        await checker.checkAll();
+        expect(mockNotifier.sendBatchedUpdates).toHaveBeenCalledWith([
+            { name: 'Ninja', oldVersion: '1.11.1', newVersion: '1.12.0' }
+        ]);
+        expect(mockStorage.setVersion).toHaveBeenCalledWith('Ninja', '1.12.0');
+    });
+    it('skips notification on first run (no stored version)', async () => {
+        mockStorage.getVersion.mockReturnValue(null);
+        vi.mocked(fetchVersion).mockResolvedValue('1.12.0');
+        await checker.checkAll();
+        expect(mockNotifier.sendBatchedUpdates).toHaveBeenCalledWith([]);
+        expect(mockStorage.setVersion).toHaveBeenCalledTimes(2);
+    });
+    it('notifies on fetch failure', async () => {
+        mockStorage.getVersion.mockReturnValue('1.11.1');
+        vi.mocked(fetchVersion)
+            .mockRejectedValueOnce(new Error('Timeout'))
+            .mockResolvedValueOnce('2.43.0');
+        await checker.checkAll();
+        expect(mockNotifier.sendBatchedFailures).toHaveBeenCalledWith([
+            { name: 'Ninja', error: 'Timeout' }
+        ]);
+    });
+    it('does not notify when version unchanged', async () => {
+        mockStorage.getVersion.mockReturnValue('1.12.0');
+        vi.mocked(fetchVersion).mockResolvedValue('1.12.0');
+        await checker.checkAll();
+        expect(mockNotifier.sendBatchedUpdates).toHaveBeenCalledWith([]);
+        expect(mockStorage.setVersion).not.toHaveBeenCalled();
+    });
+});

package/dist/fetchers/custom.d.ts

@@ -0,0 +1,3 @@
+export declare function fetchVSCodeVersion(): Promise<string>;
+export declare function fetchClaudeCodeCLI(): Promise<string>;
+export declare function fetchCMakeVersion(): Promise<string>;

package/dist/fetchers/custom.js

@@ -0,0 +1,62 @@
+// src/fetchers/custom.ts
+export async function fetchVSCodeVersion() {
+    const response = await fetch('https://update.code.visualstudio.com/api/releases/stable');
+    if (!response.ok) {
+        throw new Error(`VSCode API error: ${response.status} ${response.statusText}`);
+    }
+    const releases = await response.json();
+    return releases[0];
+}
+export async function fetchClaudeCodeCLI() {
+    const primaryUrl = 'https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases/latest';
+    const fallbackUrl = 'https://api.github.com/repos/anthropics/claude-code/releases/latest';
+    try {
+        const response = await fetch(primaryUrl);
+        if (response.ok) {
+            const version = await response.text();
+            return version.trim();
+        }
+    }
+    catch {
+        // Fall through to fallback
+    }
+    const response = await fetch(fallbackUrl, {
+        headers: {
+            'Accept': 'application/vnd.github.v3+json',
+            'User-Agent': 'ReleaseRadar/1.0'
+        }
+    });
+    if (!response.ok) {
+        throw new Error(`Claude Code CLI fetch failed: ${response.status}`);
+    }
+    const data = await response.json();
+    return data.tag_name.replace(/^v/, '');
+}
+export async function fetchCMakeVersion() {
+    const jsonUrl = 'https://cmake.org/files/LatestRelease/cmake-latest-files-v1.json';
+    const fallbackUrl = 'https://cmake.org/files/LatestRelease/';
+    // Try JSON endpoint first
+    try {
+        const response = await fetch(jsonUrl);
+        if (response.ok) {
+            const data = await response.json();
+            return data.version.string;
+        }
+    }
+    catch {
+        // Fall through to HTML parsing
+    }
+    // Fallback: parse HTML directory listing (items are oldest to newest)
+    const response = await fetch(fallbackUrl);
+    if (!response.ok) {
+        throw new Error(`CMake fetch error: ${response.status} ${response.statusText}`);
+    }
+    const html = await response.text();
+    const matches = html.matchAll(/cmake-(\d+\.\d+\.\d+)/g);
+    const versions = [...matches].map(m => m[1]);
+    if (versions.length === 0) {
+        throw new Error('Could not parse CMake version from directory listing');
+    }
+    // Return last match (newest version)
+    return versions[versions.length - 1];
+}

package/dist/fetchers/custom.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fetchers/custom.test.js

@@ -0,0 +1,74 @@
+// src/fetchers/custom.test.ts
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { fetchVSCodeVersion, fetchClaudeCodeCLI, fetchCMakeVersion } from './custom.js';
+describe('custom fetchers', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('fetchVSCodeVersion', () => {
+        it('extracts first version from releases array', async () => {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve(['1.96.0', '1.95.3', '1.95.2'])
+            });
+            const version = await fetchVSCodeVersion();
+            expect(version).toBe('1.96.0');
+            expect(fetch).toHaveBeenCalledWith('https://update.code.visualstudio.com/api/releases/stable');
+        });
+    });
+    describe('fetchClaudeCodeCLI', () => {
+        it('extracts version from text response', async () => {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                text: () => Promise.resolve('1.0.5')
+            });
+            const version = await fetchClaudeCodeCLI();
+            expect(version).toBe('1.0.5');
+        });
+        it('falls back to GitHub on primary failure', async () => {
+            global.fetch = vi.fn()
+                .mockResolvedValueOnce({ ok: false, status: 503 })
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({ tag_name: 'v1.0.6' })
+            });
+            const version = await fetchClaudeCodeCLI();
+            expect(version).toBe('1.0.6');
+        });
+    });
+    describe('fetchCMakeVersion', () => {
+        it('extracts version from JSON endpoint', async () => {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ version: { string: '3.31.0' } })
+            });
+            const version = await fetchCMakeVersion();
+            expect(version).toBe('3.31.0');
+            expect(fetch).toHaveBeenCalledWith('https://cmake.org/files/LatestRelease/cmake-latest-files-v1.json');
+        });
+        it('falls back to HTML and returns newest (last) version', async () => {
+            const html = `
+        <a href="cmake-3.28.0-linux-x86_64.tar.gz">cmake-3.28.0-linux-x86_64.tar.gz</a>
+        <a href="cmake-3.31.0-linux-x86_64.tar.gz">cmake-3.31.0-linux-x86_64.tar.gz</a>
+      `;
+            global.fetch = vi.fn()
+                .mockResolvedValueOnce({ ok: false, status: 404 })
+                .mockResolvedValueOnce({
+                ok: true,
+                text: () => Promise.resolve(html)
+            });
+            const version = await fetchCMakeVersion();
+            expect(version).toBe('3.31.0');
+        });
+        it('throws when no version found in listing', async () => {
+            global.fetch = vi.fn()
+                .mockResolvedValueOnce({ ok: false, status: 404 })
+                .mockResolvedValueOnce({
+                ok: true,
+                text: () => Promise.resolve('<html>empty</html>')
+            });
+            await expect(fetchCMakeVersion())
+                .rejects.toThrow('Could not parse CMake version from directory listing');
+        });
+    });
+});

package/dist/fetchers/github-release.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Fetches the latest stable release version from a GitHub repository.
+ * Uses /releases/latest endpoint which excludes pre-releases and drafts by design.
+ */
+export declare function fetchGitHubRelease(repo: string): Promise<string>;

package/dist/fetchers/github-release.js

@@ -0,0 +1,21 @@
+// src/fetchers/github-release.ts
+/**
+ * Fetches the latest stable release version from a GitHub repository.
+ * Uses /releases/latest endpoint which excludes pre-releases and drafts by design.
+ */
+export async function fetchGitHubRelease(repo) {
+    // Note: /releases/latest only returns stable releases (no pre-releases or drafts)
+    const url = `https://api.github.com/repos/${repo}/releases/latest`;
+    const response = await fetch(url, {
+        headers: {
+            'Accept': 'application/vnd.github.v3+json',
+            'User-Agent': 'ReleaseRadar/1.0'
+        }
+    });
+    if (!response.ok) {
+        throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    const version = data.tag_name.replace(/^v/, '');
+    return version;
+}

package/dist/fetchers/github-release.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fetchers/github-release.test.js

@@ -0,0 +1,35 @@
+// src/fetchers/github-release.test.ts
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { fetchGitHubRelease } from './github-release.js';
+// Note: Uses /releases/latest which only returns stable releases (excludes pre-releases and drafts)
+describe('fetchGitHubRelease', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('fetches latest stable release (not pre-release)', async () => {
+        global.fetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({ tag_name: 'v1.12.0' })
+        });
+        const version = await fetchGitHubRelease('ninja-build/ninja');
+        expect(version).toBe('1.12.0');
+        expect(fetch).toHaveBeenCalledWith('https://api.github.com/repos/ninja-build/ninja/releases/latest', expect.any(Object));
+    });
+    it('handles tag without v prefix', async () => {
+        global.fetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({ tag_name: '2.44.0' })
+        });
+        const version = await fetchGitHubRelease('git-for-windows/git');
+        expect(version).toBe('2.44.0');
+    });
+    it('throws on API error', async () => {
+        global.fetch = vi.fn().mockResolvedValue({
+            ok: false,
+            status: 404,
+            statusText: 'Not Found'
+        });
+        await expect(fetchGitHubRelease('invalid/repo'))
+            .rejects.toThrow('GitHub API error: 404 Not Found');
+    });
+});

package/dist/fetchers/index.d.ts

@@ -0,0 +1,2 @@
+import type { ToolConfig } from '../types.js';
+export declare function fetchVersion(tool: ToolConfig): Promise<string>;

package/dist/fetchers/index.js

@@ -0,0 +1,36 @@
+import { fetchGitHubRelease } from './github-release.js';
+import { fetchNpmVersion } from './npm.js';
+import { fetchVSCodeMarketplace } from './vscode-marketplace.js';
+import { fetchVSCodeVersion, fetchClaudeCodeCLI, fetchCMakeVersion } from './custom.js';
+export async function fetchVersion(tool) {
+    switch (tool.type) {
+        case 'github':
+            if (!tool.repo)
+                throw new Error(`Missing repo for ${tool.name}`);
+            return fetchGitHubRelease(tool.repo);
+        case 'npm':
+            if (!tool.package)
+                throw new Error(`Missing package for ${tool.name}`);
+            return fetchNpmVersion(tool.package);
+        case 'vscode-marketplace':
+            if (!tool.extensionId)
+                throw new Error(`Missing extensionId for ${tool.name}`);
+            return fetchVSCodeMarketplace(tool.extensionId);
+        case 'custom':
+            return fetchCustom(tool);
+        default:
+            throw new Error(`Unknown tool type: ${tool.type}`);
+    }
+}
+async function fetchCustom(tool) {
+    switch (tool.customFetcher) {
+        case 'vscode':
+            return fetchVSCodeVersion();
+        case 'claude-cli':
+            return fetchClaudeCodeCLI();
+        case 'cmake':
+            return fetchCMakeVersion();
+        default:
+            throw new Error(`Unknown custom fetcher: ${tool.customFetcher}`);
+    }
+}

package/dist/fetchers/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fetchers/index.test.js

@@ -0,0 +1,43 @@
+// src/fetchers/index.test.ts
+import { describe, it, expect, vi } from 'vitest';
+import { fetchVersion } from './index.js';
+vi.mock('./github-release.js', () => ({
+    fetchGitHubRelease: vi.fn().mockResolvedValue('1.12.0')
+}));
+vi.mock('./npm.js', () => ({
+    fetchNpmVersion: vi.fn().mockResolvedValue('2.1.0')
+}));
+vi.mock('./vscode-marketplace.js', () => ({
+    fetchVSCodeMarketplace: vi.fn().mockResolvedValue('1.2.3')
+}));
+vi.mock('./custom.js', () => ({
+    fetchVSCodeVersion: vi.fn().mockResolvedValue('1.96.0'),
+    fetchClaudeCodeCLI: vi.fn().mockResolvedValue('1.0.5'),
+    fetchCMakeVersion: vi.fn().mockResolvedValue('3.28.0')
+}));
+describe('fetchVersion', () => {
+    it('routes github type to GitHub fetcher', async () => {
+        const tool = { name: 'Ninja', type: 'github', repo: 'ninja-build/ninja' };
+        const version = await fetchVersion(tool);
+        expect(version).toBe('1.12.0');
+    });
+    it('routes npm type to npm fetcher', async () => {
+        const tool = { name: 'Ralphy', type: 'npm', package: 'ralphy-cli' };
+        const version = await fetchVersion(tool);
+        expect(version).toBe('2.1.0');
+    });
+    it('routes vscode-marketplace type', async () => {
+        const tool = { name: 'Claude Code', type: 'vscode-marketplace', extensionId: 'anthropic.claude-code' };
+        const version = await fetchVersion(tool);
+        expect(version).toBe('1.2.3');
+    });
+    it('routes custom type with customFetcher', async () => {
+        const tool = { name: 'VSCode', type: 'custom', customFetcher: 'vscode' };
+        const version = await fetchVersion(tool);
+        expect(version).toBe('1.96.0');
+    });
+    it('throws for unknown type', async () => {
+        const tool = { name: 'Unknown', type: 'invalid' };
+        await expect(fetchVersion(tool)).rejects.toThrow('Unknown tool type: invalid');
+    });
+});

package/dist/fetchers/npm.d.ts

@@ -0,0 +1 @@
+export declare function fetchNpmVersion(packageName: string): Promise<string>;

package/dist/fetchers/npm.js

@@ -0,0 +1,10 @@
+// src/fetchers/npm.ts
+export async function fetchNpmVersion(packageName) {
+    const url = `https://registry.npmjs.org/${packageName}/latest`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`npm registry error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.version;
+}

package/dist/fetchers/npm.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fetchers/npm.test.js

@@ -0,0 +1,26 @@
+// src/fetchers/npm.test.ts
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { fetchNpmVersion } from './npm.js';
+describe('fetchNpmVersion', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('extracts version from npm registry', async () => {
+        global.fetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({ version: '2.1.0' })
+        });
+        const version = await fetchNpmVersion('ralphy-cli');
+        expect(version).toBe('2.1.0');
+        expect(fetch).toHaveBeenCalledWith('https://registry.npmjs.org/ralphy-cli/latest');
+    });
+    it('throws on registry error', async () => {
+        global.fetch = vi.fn().mockResolvedValue({
+            ok: false,
+            status: 404,
+            statusText: 'Not Found'
+        });
+        await expect(fetchNpmVersion('nonexistent-package'))
+            .rejects.toThrow('npm registry error: 404 Not Found');
+    });
+});

package/dist/fetchers/vscode-marketplace.d.ts

@@ -0,0 +1 @@
+export declare function fetchVSCodeMarketplace(extensionId: string): Promise<string>;

package/dist/fetchers/vscode-marketplace.js

@@ -0,0 +1,25 @@
+export async function fetchVSCodeMarketplace(extensionId) {
+    const url = 'https://marketplace.visualstudio.com/_apis/public/gallery/extensionquery';
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json;api-version=7.1-preview.1'
+        },
+        body: JSON.stringify({
+            filters: [{
+                    criteria: [{ filterType: 7, value: extensionId }]
+                }],
+            flags: 0x200 // Include versions
+        })
+    });
+    if (!response.ok) {
+        throw new Error(`VS Code Marketplace error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    const extension = data.results[0]?.extensions[0];
+    if (!extension) {
+        throw new Error(`Extension not found: ${extensionId}`);
+    }
+    return extension.versions[0].version;
+}

package/dist/fetchers/vscode-marketplace.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fetchers/vscode-marketplace.test.js

@@ -0,0 +1,39 @@
+// src/fetchers/vscode-marketplace.test.ts
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { fetchVSCodeMarketplace } from './vscode-marketplace.js';
+describe('fetchVSCodeMarketplace', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('extracts version from marketplace API', async () => {
+        global.fetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                results: [{
+                        extensions: [{
+                                versions: [{ version: '1.2.3' }]
+                            }]
+                    }]
+            })
+        });
+        const version = await fetchVSCodeMarketplace('anthropic.claude-code');
+        expect(version).toBe('1.2.3');
+    });
+    it('throws on API error', async () => {
+        global.fetch = vi.fn().mockResolvedValue({
+            ok: false,
+            status: 500,
+            statusText: 'Internal Server Error'
+        });
+        await expect(fetchVSCodeMarketplace('some.extension'))
+            .rejects.toThrow('VS Code Marketplace error: 500 Internal Server Error');
+    });
+    it('throws when extension not found', async () => {
+        global.fetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({ results: [{ extensions: [] }] })
+        });
+        await expect(fetchVSCodeMarketplace('nonexistent.extension'))
+            .rejects.toThrow('Extension not found: nonexistent.extension');
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,85 @@
+// src/index.ts
+import { config } from 'dotenv';
+config();
+import TelegramBot from 'node-telegram-bot-api';
+import cron from 'node-cron';
+import { readFileSync, writeFileSync } from 'fs';
+import { Storage } from './storage.js';
+import { Notifier } from './notifier.js';
+import { Checker } from './checker.js';
+const BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN;
+const CHAT_ID = process.env.TELEGRAM_CHAT_ID;
+const CONFIG_PATH = './config/tools.json';
+if (!BOT_TOKEN || !CHAT_ID) {
+    console.error('Missing TELEGRAM_BOT_TOKEN or TELEGRAM_CHAT_ID environment variables');
+    process.exit(1);
+}
+// Load config
+let configData = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+// Initialize components
+const bot = new TelegramBot(BOT_TOKEN, { polling: true });
+const storage = new Storage('./data/versions.json');
+const notifier = new Notifier(bot, CHAT_ID);
+const checker = new Checker(configData.tools, storage, notifier);
+// Track scheduled task for rescheduling
+let scheduledTask = null;
+function scheduleChecks(intervalHours) {
+    if (scheduledTask) {
+        scheduledTask.stop();
+    }
+    const cronExpression = `0 */${intervalHours} * * *`;
+    scheduledTask = cron.schedule(cronExpression, async () => {
+        console.log(`[${new Date().toISOString()}] Running scheduled check`);
+        await checker.checkAll();
+    });
+    console.log(`Scheduled checks every ${intervalHours} hours`);
+}
+// Bot commands
+bot.onText(/\/check/, async (msg) => {
+    if (msg.chat.id.toString() !== CHAT_ID)
+        return;
+    await bot.sendMessage(CHAT_ID, 'Checking for updates...');
+    await checker.checkAll();
+    await bot.sendMessage(CHAT_ID, 'Check complete.');
+});
+bot.onText(/\/status/, async (msg) => {
+    if (msg.chat.id.toString() !== CHAT_ID)
+        return;
+    const state = storage.load();
+    const lines = Object.entries(state.versions)
+        .map(([name, version]) => `${name}: ${version}`)
+        .sort();
+    const message = lines.length > 0
+        ? lines.join('\n')
+        : 'No versions tracked yet. Run /check first.';
+    await bot.sendMessage(CHAT_ID, message);
+});
+bot.onText(/\/interval$/, async (msg) => {
+    if (msg.chat.id.toString() !== CHAT_ID)
+        return;
+    await bot.sendMessage(CHAT_ID, `Check interval: every ${configData.checkIntervalHours} hours`);
+});
+bot.onText(/\/setinterval(?:\s+(\d+))?/, async (msg, match) => {
+    if (msg.chat.id.toString() !== CHAT_ID)
+        return;
+    const hoursStr = match?.[1];
+    if (!hoursStr) {
+        await bot.sendMessage(CHAT_ID, 'Usage: /setinterval <hours>\nExample: /setinterval 12');
+        return;
+    }
+    const hours = parseInt(hoursStr, 10);
+    if (hours < 1 || hours > 24) {
+        await bot.sendMessage(CHAT_ID, 'Interval must be between 1 and 24 hours');
+        return;
+    }
+    // Update config
+    configData.checkIntervalHours = hours;
+    writeFileSync(CONFIG_PATH, JSON.stringify(configData, null, 2));
+    // Reschedule
+    scheduleChecks(hours);
+    await bot.sendMessage(CHAT_ID, `Check interval updated to every ${hours} hours`);
+});
+// Start scheduled checks
+scheduleChecks(configData.checkIntervalHours);
+console.log(`ReleaseRadar started. Checking every ${configData.checkIntervalHours} hours.`);
+console.log(`Tracking ${configData.tools.length} tools.`);

package/dist/notifier.d.ts

@@ -0,0 +1,19 @@
+import TelegramBot from 'node-telegram-bot-api';
+export interface UpdateInfo {
+    name: string;
+    oldVersion: string;
+    newVersion: string;
+}
+export interface FailureInfo {
+    name: string;
+    error: string;
+}
+export declare class Notifier {
+    private bot;
+    private chatId;
+    constructor(bot: TelegramBot, chatId: string);
+    sendUpdate(name: string, oldVersion: string, newVersion: string): Promise<void>;
+    sendBatchedUpdates(updates: UpdateInfo[]): Promise<void>;
+    sendFailure(name: string, error: string): Promise<void>;
+    sendBatchedFailures(failures: FailureInfo[]): Promise<void>;
+}

package/dist/notifier.js

@@ -0,0 +1,30 @@
+export class Notifier {
+    bot;
+    chatId;
+    constructor(bot, chatId) {
+        this.bot = bot;
+        this.chatId = chatId;
+    }
+    async sendUpdate(name, oldVersion, newVersion) {
+        await this.bot.sendMessage(this.chatId, `🔄 ${name}: ${oldVersion} → ${newVersion}`);
+    }
+    async sendBatchedUpdates(updates) {
+        if (updates.length === 0)
+            return;
+        const message = updates
+            .map(u => `🔄 ${u.name}: ${u.oldVersion} → ${u.newVersion}`)
+            .join('\n');
+        await this.bot.sendMessage(this.chatId, message);
+    }
+    async sendFailure(name, error) {
+        await this.bot.sendMessage(this.chatId, `⚠️ Failed to check ${name}: ${error}`);
+    }
+    async sendBatchedFailures(failures) {
+        if (failures.length === 0)
+            return;
+        const message = failures
+            .map(f => `⚠️ Failed to check ${f.name}: ${f.error}`)
+            .join('\n');
+        await this.bot.sendMessage(this.chatId, message);
+    }
+}

package/dist/notifier.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/notifier.test.js

@@ -0,0 +1,37 @@
+// src/notifier.test.ts
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Notifier } from './notifier.js';
+describe('Notifier', () => {
+    let mockBot;
+    let notifier;
+    beforeEach(() => {
+        mockBot = { sendMessage: vi.fn().mockResolvedValue({}) };
+        notifier = new Notifier(mockBot, '123456789');
+    });
+    it('sends update notification with correct format', async () => {
+        await notifier.sendUpdate('Ninja', '1.11.1', '1.12.0');
+        expect(mockBot.sendMessage).toHaveBeenCalledWith('123456789', '🔄 Ninja: 1.11.1 → 1.12.0');
+    });
+    it('sends batched updates as single message', async () => {
+        const updates = [
+            { name: 'Ninja', oldVersion: '1.11.1', newVersion: '1.12.0' },
+            { name: 'Git', oldVersion: '2.43.0', newVersion: '2.44.0' }
+        ];
+        await notifier.sendBatchedUpdates(updates);
+        expect(mockBot.sendMessage).toHaveBeenCalledTimes(1);
+        expect(mockBot.sendMessage).toHaveBeenCalledWith('123456789', '🔄 Ninja: 1.11.1 → 1.12.0\n🔄 Git: 2.43.0 → 2.44.0');
+    });
+    it('sends failure notification', async () => {
+        await notifier.sendFailure('CMake', 'Request timeout');
+        expect(mockBot.sendMessage).toHaveBeenCalledWith('123456789', '⚠️ Failed to check CMake: Request timeout');
+    });
+    it('sends batched failures as single message', async () => {
+        const failures = [
+            { name: 'CMake', error: 'Timeout' },
+            { name: 'VSCode', error: 'Connection refused' }
+        ];
+        await notifier.sendBatchedFailures(failures);
+        expect(mockBot.sendMessage).toHaveBeenCalledTimes(1);
+        expect(mockBot.sendMessage).toHaveBeenCalledWith('123456789', '⚠️ Failed to check CMake: Timeout\n⚠️ Failed to check VSCode: Connection refused');
+    });
+});

package/dist/storage.d.ts

@@ -0,0 +1,14 @@
+export interface StorageState {
+    lastCheck: string | null;
+    versions: Record<string, string>;
+}
+export declare class Storage {
+    private filePath;
+    private state;
+    constructor(filePath: string);
+    private ensureLoaded;
+    load(): StorageState;
+    save(state: StorageState): void;
+    getVersion(toolName: string): string | null;
+    setVersion(toolName: string, version: string): void;
+}

package/dist/storage.js

@@ -0,0 +1,37 @@
+// src/storage.ts
+import { readFileSync, writeFileSync, renameSync, existsSync } from 'fs';
+export class Storage {
+    filePath;
+    state = null;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    ensureLoaded() {
+        if (!this.state) {
+            this.state = this.load();
+        }
+        return this.state;
+    }
+    load() {
+        if (!existsSync(this.filePath)) {
+            return { lastCheck: null, versions: {} };
+        }
+        const content = readFileSync(this.filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    save(state) {
+        const tempPath = `${this.filePath}.tmp`;
+        writeFileSync(tempPath, JSON.stringify(state, null, 2));
+        renameSync(tempPath, this.filePath);
+    }
+    getVersion(toolName) {
+        const state = this.ensureLoaded();
+        return state.versions[toolName] ?? null;
+    }
+    setVersion(toolName, version) {
+        const state = this.ensureLoaded();
+        state.versions[toolName] = version;
+        state.lastCheck = new Date().toISOString();
+        this.save(state);
+    }
+}

package/dist/storage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/storage.test.js

@@ -0,0 +1,53 @@
+// src/storage.test.ts
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { Storage } from './storage.js';
+import { writeFileSync, mkdirSync, rmSync } from 'fs';
+describe('Storage', () => {
+    const testDir = './test-data';
+    const testPath = `${testDir}/versions.json`;
+    let storage;
+    beforeEach(() => {
+        mkdirSync(testDir, { recursive: true });
+        storage = new Storage(testPath);
+    });
+    afterEach(() => {
+        rmSync(testDir, { recursive: true, force: true });
+    });
+    it('returns empty state when file does not exist', () => {
+        const state = storage.load();
+        expect(state).toEqual({ lastCheck: null, versions: {} });
+    });
+    it('loads existing state from file', () => {
+        const existingState = {
+            lastCheck: '2026-01-23T10:00:00Z',
+            versions: { 'VSCode': '1.96.0' }
+        };
+        writeFileSync(testPath, JSON.stringify(existingState));
+        const state = storage.load();
+        expect(state).toEqual(existingState);
+    });
+    it('saves state to file', () => {
+        const state = {
+            lastCheck: '2026-01-23T10:00:00Z',
+            versions: { 'Ninja': '1.12.0' }
+        };
+        storage.save(state);
+        const loaded = storage.load();
+        expect(loaded).toEqual(state);
+    });
+    it('getVersion returns null for unknown tool', () => {
+        expect(storage.getVersion('Unknown')).toBeNull();
+    });
+    it('getVersion returns stored version', () => {
+        const state = { lastCheck: null, versions: { 'Git': '2.44.0' } };
+        writeFileSync(testPath, JSON.stringify(state));
+        storage = new Storage(testPath); // reload
+        expect(storage.getVersion('Git')).toBe('2.44.0');
+    });
+    it('setVersion updates and persists', () => {
+        storage.setVersion('Ninja', '1.12.0');
+        // Reload and verify
+        const newStorage = new Storage(testPath);
+        expect(newStorage.getVersion('Ninja')).toBe('1.12.0');
+    });
+});

package/dist/types.d.ts

@@ -0,0 +1,14 @@
+export interface ToolConfig {
+    name: string;
+    type: 'github' | 'npm' | 'vscode-marketplace' | 'custom';
+    repo?: string;
+    package?: string;
+    extensionId?: string;
+    url?: string;
+    fallbackUrl?: string;
+    customFetcher?: string;
+}
+export interface Config {
+    checkIntervalHours: number;
+    tools: ToolConfig[];
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@lvnt/release-radar",
+  "version": "1.0.0",
+  "description": "Monitor tool versions and notify via Telegram when updates are detected",
+  "main": "dist/index.js",
+  "bin": {
+    "release-radar": "./bin/release-radar.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "release",
+    "monitor",
+    "version",
+    "telegram",
+    "notification",
+    "github",
+    "npm",
+    "vscode"
+  ],
+  "author": "lvnt",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lvntbkdmr/release-radar.git"
+  },
+  "bugs": {
+    "url": "https://github.com/lvntbkdmr/release-radar/issues"
+  },
+  "homepage": "https://github.com/lvntbkdmr/release-radar#readme",
+  "files": [
+    "dist",
+    "bin",
+    "config",
+    ".env.example"
+  ],
+  "dependencies": {
+    "dotenv": "^17.2.3",
+    "node-cron": "^4.2.1",
+    "node-telegram-bot-api": "^0.67.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.10",
+    "@types/node-cron": "^3.0.11",
+    "@types/node-telegram-bot-api": "^0.64.13",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}