@lvnt/release-radar 1.1.7 → 1.3.0

package/config/downloads.json

@@ -0,0 +1,17 @@
+{
+  "Ninja": {
+    "displayName": "Ninja",
+    "downloadUrl": "github.com/ninja-build/ninja/releases/download/v{{VERSION}}/ninja-linux.zip",
+    "filename": "ninja-{{VERSION}}-linux.zip"
+  },
+  "CMake": {
+    "displayName": "CMake",
+    "downloadUrl": "github.com/Kitware/CMake/releases/download/v{{VERSION}}/cmake-{{VERSION}}-linux-x86_64.tar.gz",
+    "filename": "cmake-{{VERSION}}-linux-x86_64.tar.gz"
+  },
+  "Git": {
+    "displayName": "Git for Windows",
+    "downloadUrl": "github.com/git-for-windows/git/releases/download/v{{VERSION}}.windows.1/Git-{{VERSION}}-64-bit.exe",
+    "filename": "Git-{{VERSION}}-64-bit.exe"
+  }
+}

package/dist/index.js

@@ -7,6 +7,7 @@ import { readFileSync, writeFileSync } from 'fs';
 import { Storage } from './storage.js';
 import { Notifier } from './notifier.js';
 import { Checker } from './checker.js';
+import { generateVersionsJson } from './versions-generator.js';
 const BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN;
 const CHAT_ID = process.env.TELEGRAM_CHAT_ID;
 const CONFIG_PATH = './config/tools.json';
@@ -16,6 +17,14 @@ if (!BOT_TOKEN || !CHAT_ID) {
 }
 // Load config
 let configData = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+const DOWNLOADS_PATH = './config/downloads.json';
+let downloadsConfig = {};
+try {
+    downloadsConfig = JSON.parse(readFileSync(DOWNLOADS_PATH, 'utf-8'));
+}
+catch {
+    console.log('No downloads.json found, CLI generation disabled');
+}
 // Initialize components
 const bot = new TelegramBot(BOT_TOKEN, { polling: true });
 const storage = new Storage('./data/versions.json');
@@ -23,14 +32,29 @@ const notifier = new Notifier(bot, CHAT_ID);
 const checker = new Checker(configData.tools, storage, notifier);
 // Track scheduled task for rescheduling
 let scheduledTask = null;
+let lastCheckTime = null;
+let nextCheckTime = null;
+function calculateNextCheckTime(intervalHours) {
+    const now = new Date();
+    const next = new Date(now);
+    next.setMinutes(0, 0, 0);
+    next.setHours(Math.ceil(now.getHours() / intervalHours) * intervalHours);
+    if (next <= now) {
+        next.setHours(next.getHours() + intervalHours);
+    }
+    return next;
+}
 function scheduleChecks(intervalHours) {
     if (scheduledTask) {
         scheduledTask.stop();
     }
+    nextCheckTime = calculateNextCheckTime(intervalHours);
     const cronExpression = `0 */${intervalHours} * * *`;
     scheduledTask = cron.schedule(cronExpression, async () => {
         console.log(`[${new Date().toISOString()}] Running scheduled check`);
+        lastCheckTime = new Date();
         await checker.checkAll();
+        nextCheckTime = calculateNextCheckTime(intervalHours);
     });
     console.log(`Scheduled checks every ${intervalHours} hours`);
 }
@@ -39,7 +63,9 @@ bot.onText(/\/check/, async (msg) => {
     if (msg.chat.id.toString() !== CHAT_ID)
         return;
     await bot.sendMessage(CHAT_ID, 'Checking for updates...');
+    lastCheckTime = new Date();
     await checker.checkAll();
+    nextCheckTime = calculateNextCheckTime(configData.checkIntervalHours);
     await bot.sendMessage(CHAT_ID, 'Check complete.');
 });
 bot.onText(/\/status/, async (msg) => {
@@ -49,9 +75,29 @@ bot.onText(/\/status/, async (msg) => {
     const lines = Object.entries(state.versions)
         .map(([name, version]) => `${name}: ${version}`)
         .sort();
-    const message = lines.length > 0
+    let message = lines.length > 0
         ? lines.join('\n')
         : 'No versions tracked yet. Run /check first.';
+    // Add timing info
+    message += '\n\n---';
+    if (lastCheckTime) {
+        const ago = Math.round((Date.now() - lastCheckTime.getTime()) / 60000);
+        message += `\nLast check: ${ago} min ago`;
+    }
+    else {
+        message += '\nLast check: not yet';
+    }
+    if (nextCheckTime) {
+        const mins = Math.round((nextCheckTime.getTime() - Date.now()) / 60000);
+        if (mins > 0) {
+            const hours = Math.floor(mins / 60);
+            const remainingMins = mins % 60;
+            message += `\nNext check: in ${hours > 0 ? hours + 'h ' : ''}${remainingMins}m`;
+        }
+        else {
+            message += '\nNext check: soon';
+        }
+    }
     await bot.sendMessage(CHAT_ID, message);
 });
 bot.onText(/\/interval$/, async (msg) => {
@@ -79,6 +125,19 @@ bot.onText(/\/setinterval(?:\s+(\d+))?/, async (msg, match) => {
     scheduleChecks(hours);
     await bot.sendMessage(CHAT_ID, `Check interval updated to every ${hours} hours`);
 });
+bot.onText(/\/generate/, async (msg) => {
+    if (msg.chat.id.toString() !== CHAT_ID)
+        return;
+    if (Object.keys(downloadsConfig).length === 0) {
+        await bot.sendMessage(CHAT_ID, 'No downloads.json configured.');
+        return;
+    }
+    const state = storage.load();
+    const versionsJson = generateVersionsJson(state.versions, downloadsConfig);
+    const outputPath = './data/versions.json';
+    writeFileSync(outputPath, JSON.stringify(versionsJson, null, 2));
+    await bot.sendMessage(CHAT_ID, `Generated versions.json with ${versionsJson.tools.length} tools.\nPath: ${outputPath}`);
+});
 // Start scheduled checks
 scheduleChecks(configData.checkIntervalHours);
 console.log(`ReleaseRadar started. Checking every ${configData.checkIntervalHours} hours.`);

package/dist/types.d.ts

@@ -12,3 +12,23 @@ export interface Config {
     checkIntervalHours: number;
     tools: ToolConfig[];
 }
+export interface DownloadConfig {
+    displayName: string;
+    downloadUrl: string;
+    filename: string;
+}
+export interface DownloadsConfig {
+    [toolName: string]: DownloadConfig;
+}
+export interface VersionsJsonTool {
+    name: string;
+    displayName: string;
+    version: string;
+    publishedAt: string;
+    downloadUrl: string;
+    filename: string;
+}
+export interface VersionsJson {
+    generatedAt: string;
+    tools: VersionsJsonTool[];
+}

package/dist/versions-generator.d.ts

@@ -0,0 +1,2 @@
+import type { DownloadsConfig, VersionsJson } from './types.js';
+export declare function generateVersionsJson(versions: Record<string, string>, downloads: DownloadsConfig): VersionsJson;

package/dist/versions-generator.js

@@ -0,0 +1,23 @@
+export function generateVersionsJson(versions, downloads) {
+    const tools = [];
+    for (const [toolName, version] of Object.entries(versions)) {
+        const downloadConfig = downloads[toolName];
+        if (!downloadConfig)
+            continue;
+        const downloadUrl = '{{NEXUS_URL}}/' +
+            downloadConfig.downloadUrl.replace(/\{\{VERSION\}\}/g, version);
+        const filename = downloadConfig.filename.replace(/\{\{VERSION\}\}/g, version);
+        tools.push({
+            name: toolName,
+            displayName: downloadConfig.displayName,
+            version,
+            publishedAt: new Date().toISOString(),
+            downloadUrl,
+            filename,
+        });
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        tools,
+    };
+}

package/dist/versions-generator.test.d.ts

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

package/dist/versions-generator.test.js

@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'vitest';
+import { generateVersionsJson } from './versions-generator.js';
+describe('generateVersionsJson', () => {
+    it('merges version data with download config', () => {
+        const versions = {
+            'Ninja': '1.12.0',
+            'CMake': '3.28.0',
+        };
+        const downloads = {
+            'Ninja': {
+                displayName: 'Ninja Build',
+                downloadUrl: 'github.com/ninja-build/ninja/releases/download/v{{VERSION}}/ninja-linux.zip',
+                filename: 'ninja-{{VERSION}}-linux.zip',
+            },
+            'CMake': {
+                displayName: 'CMake',
+                downloadUrl: 'github.com/Kitware/CMake/releases/download/v{{VERSION}}/cmake-{{VERSION}}.tar.gz',
+                filename: 'cmake-{{VERSION}}.tar.gz',
+            },
+        };
+        const result = generateVersionsJson(versions, downloads);
+        expect(result.tools).toHaveLength(2);
+        expect(result.generatedAt).toBeDefined();
+        const ninja = result.tools.find(t => t.name === 'Ninja');
+        expect(ninja).toBeDefined();
+        expect(ninja.displayName).toBe('Ninja Build');
+        expect(ninja.version).toBe('1.12.0');
+        expect(ninja.downloadUrl).toBe('{{NEXUS_URL}}/github.com/ninja-build/ninja/releases/download/v1.12.0/ninja-linux.zip');
+        expect(ninja.filename).toBe('ninja-1.12.0-linux.zip');
+    });
+    it('only includes tools that have download config', () => {
+        const versions = {
+            'Ninja': '1.12.0',
+            'UnknownTool': '1.0.0',
+        };
+        const downloads = {
+            'Ninja': {
+                displayName: 'Ninja',
+                downloadUrl: 'github.com/ninja/releases/{{VERSION}}/ninja.zip',
+                filename: 'ninja-{{VERSION}}.zip',
+            },
+        };
+        const result = generateVersionsJson(versions, downloads);
+        expect(result.tools).toHaveLength(1);
+        expect(result.tools[0].name).toBe('Ninja');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvnt/release-radar",
-  "version": "1.1.7",
+  "version": "1.3.0",
   "description": "Monitor tool versions and notify via Telegram when updates are detected",
   "main": "dist/index.js",
   "bin": {