@lvnt/release-radar 1.2.0 → 1.4.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/checker.d.ts

@@ -6,5 +6,8 @@ export declare class Checker {
     private storage;
     private notifier;
     constructor(tools: ToolConfig[], storage: Storage, notifier: Notifier);
-    checkAll(): Promise<void>;
+    checkAll(): Promise<{
+        hasUpdates: boolean;
+        updateCount: number;
+    }>;
 }

package/dist/checker.js

@@ -31,5 +31,6 @@ export class Checker {
         }
         await this.notifier.sendBatchedUpdates(updates);
         await this.notifier.sendBatchedFailures(failures);
+        return { hasUpdates: updates.length > 0, updateCount: updates.length };
     }
 }

package/dist/checker.test.js

@@ -61,4 +61,20 @@ describe('Checker', () => {
         expect(mockNotifier.sendBatchedUpdates).toHaveBeenCalledWith([]);
         expect(mockStorage.setVersion).not.toHaveBeenCalled();
     });
+    it('returns hasUpdates true when updates found', async () => {
+        mockStorage.getVersion.mockReturnValueOnce('1.11.1').mockReturnValueOnce('2.43.0');
+        vi.mocked(fetchVersion)
+            .mockResolvedValueOnce('1.12.0')
+            .mockResolvedValueOnce('2.43.0');
+        const result = await checker.checkAll();
+        expect(result.hasUpdates).toBe(true);
+        expect(result.updateCount).toBe(1);
+    });
+    it('returns hasUpdates false when no updates', async () => {
+        mockStorage.getVersion.mockReturnValue('1.12.0');
+        vi.mocked(fetchVersion).mockResolvedValue('1.12.0');
+        const result = await checker.checkAll();
+        expect(result.hasUpdates).toBe(false);
+        expect(result.updateCount).toBe(0);
+    });
 });

package/dist/cli-publisher.d.ts

@@ -0,0 +1,13 @@
+import type { DownloadsConfig } from './types.js';
+export interface PublishResult {
+    success: boolean;
+    version?: string;
+    error?: string;
+}
+export declare class CliPublisher {
+    private downloadsConfig;
+    private cliPath;
+    constructor(downloadsConfig: DownloadsConfig, cliPath?: string);
+    isConfigured(): boolean;
+    publish(versions: Record<string, string>): Promise<PublishResult>;
+}

package/dist/cli-publisher.js

@@ -0,0 +1,50 @@
+// src/cli-publisher.ts
+import { execSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { generateVersionsJson } from './versions-generator.js';
+export class CliPublisher {
+    downloadsConfig;
+    cliPath;
+    constructor(downloadsConfig, cliPath = './cli') {
+        this.downloadsConfig = downloadsConfig;
+        this.cliPath = cliPath;
+    }
+    isConfigured() {
+        return Object.keys(this.downloadsConfig).length > 0 && existsSync(this.cliPath);
+    }
+    async publish(versions) {
+        if (!this.isConfigured()) {
+            return { success: false, error: 'CLI publisher not configured' };
+        }
+        try {
+            // Generate versions.json
+            const versionsJson = generateVersionsJson(versions, this.downloadsConfig);
+            // Write to data/ for reference
+            writeFileSync('./data/cli-versions.json', JSON.stringify(versionsJson, null, 2));
+            // Copy to CLI package
+            const cliVersionsPath = `${this.cliPath}/versions.json`;
+            writeFileSync(cliVersionsPath, JSON.stringify(versionsJson, null, 2));
+            // Read current CLI version
+            const pkgPath = `${this.cliPath}/package.json`;
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            const currentVersion = pkg.version;
+            // Bump patch version
+            const versionParts = currentVersion.split('.').map(Number);
+            versionParts[2]++;
+            const newVersion = versionParts.join('.');
+            pkg.version = newVersion;
+            writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+            // Build CLI
+            execSync('npm run build', { cwd: this.cliPath, stdio: 'pipe' });
+            // Publish to npm
+            execSync('npm publish --access public', { cwd: this.cliPath, stdio: 'pipe' });
+            console.log(`[CliPublisher] Published @lvnt/release-radar-cli v${newVersion}`);
+            return { success: true, version: newVersion };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`[CliPublisher] Failed to publish: ${message}`);
+            return { success: false, error: message };
+        }
+    }
+}

package/dist/index.js

@@ -7,6 +7,8 @@ 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';
+import { CliPublisher } from './cli-publisher.js';
 const BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN;
 const CHAT_ID = process.env.TELEGRAM_CHAT_ID;
 const CONFIG_PATH = './config/tools.json';
@@ -14,13 +16,24 @@ if (!BOT_TOKEN || !CHAT_ID) {
     console.error('Missing TELEGRAM_BOT_TOKEN or TELEGRAM_CHAT_ID environment variables');
     process.exit(1);
 }
+// Type-safe constants after validation
+const validatedChatId = 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');
-const notifier = new Notifier(bot, CHAT_ID);
+const notifier = new Notifier(bot, validatedChatId);
 const checker = new Checker(configData.tools, storage, notifier);
+const cliPublisher = new CliPublisher(downloadsConfig);
 // Track scheduled task for rescheduling
 let scheduledTask = null;
 let lastCheckTime = null;
@@ -44,23 +57,42 @@ function scheduleChecks(intervalHours) {
     scheduledTask = cron.schedule(cronExpression, async () => {
         console.log(`[${new Date().toISOString()}] Running scheduled check`);
         lastCheckTime = new Date();
-        await checker.checkAll();
+        const result = await checker.checkAll();
         nextCheckTime = calculateNextCheckTime(intervalHours);
+        // Auto-publish CLI if updates were detected
+        if (result.hasUpdates && cliPublisher.isConfigured()) {
+            const state = storage.load();
+            const publishResult = await cliPublisher.publish(state.versions);
+            if (publishResult.success) {
+                await bot.sendMessage(validatedChatId, `📦 CLI published: v${publishResult.version}`);
+            }
+        }
     });
     console.log(`Scheduled checks every ${intervalHours} hours`);
 }
 // Bot commands
 bot.onText(/\/check/, async (msg) => {
-    if (msg.chat.id.toString() !== CHAT_ID)
+    if (msg.chat.id.toString() !== validatedChatId)
         return;
-    await bot.sendMessage(CHAT_ID, 'Checking for updates...');
+    await bot.sendMessage(validatedChatId, 'Checking for updates...');
     lastCheckTime = new Date();
-    await checker.checkAll();
+    const result = await checker.checkAll();
     nextCheckTime = calculateNextCheckTime(configData.checkIntervalHours);
-    await bot.sendMessage(CHAT_ID, 'Check complete.');
+    // Auto-publish CLI if updates were detected
+    if (result.hasUpdates && cliPublisher.isConfigured()) {
+        const state = storage.load();
+        const publishResult = await cliPublisher.publish(state.versions);
+        if (publishResult.success) {
+            await bot.sendMessage(validatedChatId, `📦 CLI published: v${publishResult.version}`);
+        }
+        else {
+            await bot.sendMessage(validatedChatId, `⚠️ CLI publish failed: ${publishResult.error}`);
+        }
+    }
+    await bot.sendMessage(validatedChatId, 'Check complete.');
 });
 bot.onText(/\/status/, async (msg) => {
-    if (msg.chat.id.toString() !== CHAT_ID)
+    if (msg.chat.id.toString() !== validatedChatId)
         return;
     const state = storage.load();
     const lines = Object.entries(state.versions)
@@ -89,24 +121,24 @@ bot.onText(/\/status/, async (msg) => {
             message += '\nNext check: soon';
         }
     }
-    await bot.sendMessage(CHAT_ID, message);
+    await bot.sendMessage(validatedChatId, message);
 });
 bot.onText(/\/interval$/, async (msg) => {
-    if (msg.chat.id.toString() !== CHAT_ID)
+    if (msg.chat.id.toString() !== validatedChatId)
         return;
-    await bot.sendMessage(CHAT_ID, `Check interval: every ${configData.checkIntervalHours} hours`);
+    await bot.sendMessage(validatedChatId, `Check interval: every ${configData.checkIntervalHours} hours`);
 });
 bot.onText(/\/setinterval(?:\s+(\d+))?/, async (msg, match) => {
-    if (msg.chat.id.toString() !== CHAT_ID)
+    if (msg.chat.id.toString() !== validatedChatId)
         return;
     const hoursStr = match?.[1];
     if (!hoursStr) {
-        await bot.sendMessage(CHAT_ID, 'Usage: /setinterval <hours>\nExample: /setinterval 12');
+        await bot.sendMessage(validatedChatId, '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');
+        await bot.sendMessage(validatedChatId, 'Interval must be between 1 and 24 hours');
         return;
     }
     // Update config
@@ -114,7 +146,37 @@ bot.onText(/\/setinterval(?:\s+(\d+))?/, async (msg, match) => {
     writeFileSync(CONFIG_PATH, JSON.stringify(configData, null, 2));
     // Reschedule
     scheduleChecks(hours);
-    await bot.sendMessage(CHAT_ID, `Check interval updated to every ${hours} hours`);
+    await bot.sendMessage(validatedChatId, `Check interval updated to every ${hours} hours`);
+});
+bot.onText(/\/generate/, async (msg) => {
+    if (msg.chat.id.toString() !== validatedChatId)
+        return;
+    if (Object.keys(downloadsConfig).length === 0) {
+        await bot.sendMessage(validatedChatId, 'No downloads.json configured.');
+        return;
+    }
+    const state = storage.load();
+    const versionsJson = generateVersionsJson(state.versions, downloadsConfig);
+    const outputPath = './data/cli-versions.json';
+    writeFileSync(outputPath, JSON.stringify(versionsJson, null, 2));
+    await bot.sendMessage(CHAT_ID, `Generated versions.json with ${versionsJson.tools.length} tools.\nPath: ${outputPath}`);
+});
+bot.onText(/\/publishcli/, async (msg) => {
+    if (msg.chat.id.toString() !== validatedChatId)
+        return;
+    if (!cliPublisher.isConfigured()) {
+        await bot.sendMessage(validatedChatId, 'CLI publisher not configured. Check downloads.json and cli/ directory.');
+        return;
+    }
+    await bot.sendMessage(validatedChatId, 'Publishing CLI...');
+    const state = storage.load();
+    const result = await cliPublisher.publish(state.versions);
+    if (result.success) {
+        await bot.sendMessage(validatedChatId, `✅ CLI published: v${result.version}`);
+    }
+    else {
+        await bot.sendMessage(validatedChatId, `❌ CLI publish failed: ${result.error}`);
+    }
 });
 // Start scheduled checks
 scheduleChecks(configData.checkIntervalHours);

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.2.0",
+  "version": "1.4.0",
   "description": "Monitor tool versions and notify via Telegram when updates are detected",
   "main": "dist/index.js",
   "bin": {