@lvnt/release-radar 1.3.0 → 1.4.0

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

@@ -8,6 +8,7 @@ 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';
@@ -15,6 +16,8 @@ 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';
@@ -28,8 +31,9 @@ catch {
 // 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;
@@ -53,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)
@@ -98,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
@@ -123,21 +146,38 @@ 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() !== CHAT_ID)
+    if (msg.chat.id.toString() !== validatedChatId)
         return;
     if (Object.keys(downloadsConfig).length === 0) {
-        await bot.sendMessage(CHAT_ID, 'No downloads.json configured.');
+        await bot.sendMessage(validatedChatId, 'No downloads.json configured.');
         return;
     }
     const state = storage.load();
     const versionsJson = generateVersionsJson(state.versions, downloadsConfig);
-    const outputPath = './data/versions.json';
+    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);
 console.log(`ReleaseRadar started. Checking every ${configData.checkIntervalHours} hours.`);

package/package.json

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