@lvnt/release-radar-cli 0.1.0

package/bin/release-radar-cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/config.d.ts

@@ -0,0 +1,11 @@
+export interface CliConfig {
+    nexusUrl: string;
+    downloadDir: string;
+}
+export declare class ConfigManager {
+    private configPath;
+    constructor(baseDir?: string);
+    isConfigured(): boolean;
+    load(): CliConfig;
+    save(config: CliConfig): void;
+}

package/dist/config.js

@@ -0,0 +1,23 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+export class ConfigManager {
+    configPath;
+    constructor(baseDir) {
+        const dir = baseDir ?? join(homedir(), '.release-radar-cli');
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        this.configPath = join(dir, 'config.json');
+    }
+    isConfigured() {
+        return existsSync(this.configPath);
+    }
+    load() {
+        const content = readFileSync(this.configPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    save(config) {
+        writeFileSync(this.configPath, JSON.stringify(config, null, 2));
+    }
+}

package/dist/config.test.d.ts

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

package/dist/config.test.js

@@ -0,0 +1,38 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { ConfigManager } from './config.js';
+import { mkdtempSync, rmSync, existsSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+describe('ConfigManager', () => {
+    let tempDir;
+    let configManager;
+    beforeEach(() => {
+        tempDir = mkdtempSync(join(tmpdir(), 'cli-test-'));
+        configManager = new ConfigManager(tempDir);
+    });
+    afterEach(() => {
+        rmSync(tempDir, { recursive: true });
+    });
+    it('returns false for isConfigured when no config exists', () => {
+        expect(configManager.isConfigured()).toBe(false);
+    });
+    it('saves and loads config correctly', () => {
+        configManager.save({
+            nexusUrl: 'http://nexus.local',
+            downloadDir: '/downloads',
+        });
+        expect(configManager.isConfigured()).toBe(true);
+        const loaded = configManager.load();
+        expect(loaded.nexusUrl).toBe('http://nexus.local');
+        expect(loaded.downloadDir).toBe('/downloads');
+    });
+    it('creates config directory if it does not exist', () => {
+        const configPath = join(tempDir, 'config.json');
+        expect(existsSync(configPath)).toBe(false);
+        configManager.save({
+            nexusUrl: 'http://nexus.local',
+            downloadDir: '/downloads',
+        });
+        expect(existsSync(configPath)).toBe(true);
+    });
+});

package/dist/downloader.d.ts

@@ -0,0 +1,7 @@
+export declare function replaceNexusUrl(url: string, nexusUrl: string): string;
+export declare function buildWgetCommand(url: string, outputPath: string): string;
+export interface DownloadResult {
+    success: boolean;
+    error?: string;
+}
+export declare function downloadFile(url: string, downloadDir: string, filename: string, nexusUrl: string): DownloadResult;

package/dist/downloader.js

@@ -0,0 +1,25 @@
+import { execSync } from 'child_process';
+import { join } from 'path';
+import { existsSync, mkdirSync } from 'fs';
+export function replaceNexusUrl(url, nexusUrl) {
+    return url.replace('{{NEXUS_URL}}', nexusUrl);
+}
+export function buildWgetCommand(url, outputPath) {
+    return `wget -O "${outputPath}" "${url}"`;
+}
+export function downloadFile(url, downloadDir, filename, nexusUrl) {
+    const resolvedUrl = replaceNexusUrl(url, nexusUrl);
+    if (!existsSync(downloadDir)) {
+        mkdirSync(downloadDir, { recursive: true });
+    }
+    const outputPath = join(downloadDir, filename);
+    const command = buildWgetCommand(resolvedUrl, outputPath);
+    try {
+        execSync(command, { stdio: 'inherit' });
+        return { success: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { success: false, error: message };
+    }
+}

package/dist/downloader.test.d.ts

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

package/dist/downloader.test.js

@@ -0,0 +1,17 @@
+import { describe, it, expect } from 'vitest';
+import { buildWgetCommand, replaceNexusUrl } from './downloader.js';
+describe('downloader', () => {
+    describe('replaceNexusUrl', () => {
+        it('replaces {{NEXUS_URL}} placeholder', () => {
+            const url = '{{NEXUS_URL}}/github.com/ninja/v1.0/ninja.zip';
+            const result = replaceNexusUrl(url, 'http://nexus.local');
+            expect(result).toBe('http://nexus.local/github.com/ninja/v1.0/ninja.zip');
+        });
+    });
+    describe('buildWgetCommand', () => {
+        it('builds correct wget command', () => {
+            const cmd = buildWgetCommand('http://nexus.local/file.zip', '/downloads/file.zip');
+            expect(cmd).toBe('wget -O "/downloads/file.zip" "http://nexus.local/file.zip"');
+        });
+    });
+});

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,89 @@
+import chalk from 'chalk';
+import { ConfigManager } from './config.js';
+import { DownloadTracker } from './tracker.js';
+import { loadVersions } from './versions.js';
+import { checkAndUpdate } from './updater.js';
+import { downloadFile } from './downloader.js';
+import { promptSetup, promptToolSelection } from './ui.js';
+async function showStatus() {
+    const tracker = new DownloadTracker();
+    const versions = loadVersions();
+    const downloaded = tracker.getAll();
+    console.log(chalk.bold('\nTool Status:\n'));
+    for (const tool of versions.tools) {
+        const record = downloaded[tool.name];
+        const downloadedVersion = record?.version ?? '-';
+        let status;
+        if (!record) {
+            status = chalk.blue('NEW');
+        }
+        else if (record.version !== tool.version) {
+            status = chalk.yellow('UPDATE');
+        }
+        else {
+            status = chalk.green('✓');
+        }
+        console.log(`  ${tool.displayName.padEnd(20)} ${tool.version.padEnd(12)} ${downloadedVersion.padEnd(12)} ${status}`);
+    }
+    console.log('');
+}
+async function runConfig() {
+    const configManager = new ConfigManager();
+    const config = await promptSetup();
+    configManager.save(config);
+    console.log(chalk.green('\nConfiguration saved!'));
+}
+async function runInteractive() {
+    const configManager = new ConfigManager();
+    const tracker = new DownloadTracker();
+    // First run setup
+    if (!configManager.isConfigured()) {
+        const config = await promptSetup();
+        configManager.save(config);
+        console.log(chalk.green('\nConfiguration saved!\n'));
+    }
+    // Check for updates and restart if needed
+    await checkAndUpdate();
+    // Load data
+    const config = configManager.load();
+    const versions = loadVersions();
+    const downloaded = tracker.getAll();
+    // Show interactive menu
+    const selected = await promptToolSelection(versions.tools, downloaded, versions.generatedAt);
+    if (selected.length === 0) {
+        console.log(chalk.gray('\nNo tools selected. Exiting.'));
+        return;
+    }
+    // Download selected tools
+    console.log('');
+    for (const tool of selected) {
+        console.log(chalk.bold(`Downloading ${tool.displayName} ${tool.version}...`));
+        const result = downloadFile(tool.downloadUrl, config.downloadDir, tool.filename, config.nexusUrl);
+        if (result.success) {
+            tracker.recordDownload(tool.name, tool.version, tool.filename);
+            console.log(chalk.green(`  Saved to ${config.downloadDir}/${tool.filename} ✓\n`));
+        }
+        else {
+            console.log(chalk.red(`  Failed: ${result.error}\n`));
+        }
+    }
+    console.log(chalk.green('Done!'));
+}
+async function main() {
+    const command = process.argv[2];
+    switch (command) {
+        case 'status':
+            await showStatus();
+            break;
+        case 'config':
+            await runConfig();
+            break;
+        default:
+            await runInteractive();
+            break;
+    }
+}
+main().catch((error) => {
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+});

package/dist/tracker.d.ts

@@ -0,0 +1,15 @@
+export interface DownloadRecord {
+    version: string;
+    downloadedAt: string;
+    filename: string;
+}
+export interface DownloadedState {
+    [toolName: string]: DownloadRecord;
+}
+export declare class DownloadTracker {
+    private filePath;
+    constructor(baseDir?: string);
+    getAll(): DownloadedState;
+    getDownloadedVersion(toolName: string): string | null;
+    recordDownload(toolName: string, version: string, filename: string): void;
+}

package/dist/tracker.js

@@ -0,0 +1,32 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+export class DownloadTracker {
+    filePath;
+    constructor(baseDir) {
+        const dir = baseDir ?? join(homedir(), '.release-radar-cli');
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        this.filePath = join(dir, 'downloaded.json');
+    }
+    getAll() {
+        if (!existsSync(this.filePath)) {
+            return {};
+        }
+        return JSON.parse(readFileSync(this.filePath, 'utf-8'));
+    }
+    getDownloadedVersion(toolName) {
+        const all = this.getAll();
+        return all[toolName]?.version ?? null;
+    }
+    recordDownload(toolName, version, filename) {
+        const all = this.getAll();
+        all[toolName] = {
+            version,
+            downloadedAt: new Date().toISOString(),
+            filename,
+        };
+        writeFileSync(this.filePath, JSON.stringify(all, null, 2));
+    }
+}

package/dist/tracker.test.d.ts

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

package/dist/tracker.test.js

@@ -0,0 +1,32 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { DownloadTracker } from './tracker.js';
+import { mkdtempSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+describe('DownloadTracker', () => {
+    let tempDir;
+    let tracker;
+    beforeEach(() => {
+        tempDir = mkdtempSync(join(tmpdir(), 'tracker-test-'));
+        tracker = new DownloadTracker(tempDir);
+    });
+    afterEach(() => {
+        rmSync(tempDir, { recursive: true });
+    });
+    it('returns null for untracked tool', () => {
+        expect(tracker.getDownloadedVersion('unknown')).toBeNull();
+    });
+    it('tracks downloaded version', () => {
+        tracker.recordDownload('Ninja', '1.12.0', 'ninja-1.12.0.zip');
+        const version = tracker.getDownloadedVersion('Ninja');
+        expect(version).toBe('1.12.0');
+    });
+    it('returns all downloaded tools', () => {
+        tracker.recordDownload('Ninja', '1.12.0', 'ninja.zip');
+        tracker.recordDownload('CMake', '3.28.0', 'cmake.tar.gz');
+        const all = tracker.getAll();
+        expect(Object.keys(all)).toHaveLength(2);
+        expect(all['Ninja'].version).toBe('1.12.0');
+        expect(all['CMake'].version).toBe('3.28.0');
+    });
+});

package/dist/types.d.ts

@@ -0,0 +1,12 @@
+export interface VersionsJsonTool {
+    name: string;
+    displayName: string;
+    version: string;
+    publishedAt: string;
+    downloadUrl: string;
+    filename: string;
+}
+export interface VersionsJson {
+    generatedAt: string;
+    tools: VersionsJsonTool[];
+}

package/dist/types.js

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

package/dist/ui.d.ts

@@ -0,0 +1,15 @@
+import type { VersionsJsonTool } from './types.js';
+import type { DownloadedState } from './tracker.js';
+import type { CliConfig } from './config.js';
+export declare function promptSetup(): Promise<CliConfig>;
+interface ToolChoice {
+    name: string;
+    displayName: string;
+    version: string;
+    downloadUrl: string;
+    filename: string;
+    status: 'new' | 'update' | 'current';
+    downloadedVersion: string | null;
+}
+export declare function promptToolSelection(tools: VersionsJsonTool[], downloaded: DownloadedState, generatedAt: string): Promise<ToolChoice[]>;
+export {};

package/dist/ui.js

@@ -0,0 +1,86 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+export async function promptSetup() {
+    console.log(chalk.bold('\nWelcome to release-radar-cli!\n'));
+    console.log("Let's configure your settings.\n");
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'nexusUrl',
+            message: 'Enter your Nexus proxy base URL:',
+            validate: (input) => {
+                if (!input.trim())
+                    return 'URL is required';
+                if (!input.startsWith('http'))
+                    return 'URL must start with http:// or https://';
+                return true;
+            },
+        },
+        {
+            type: 'input',
+            name: 'downloadDir',
+            message: 'Enter download directory:',
+            default: '~/downloads/tools',
+            validate: (input) => input.trim() ? true : 'Directory is required',
+        },
+    ]);
+    return {
+        nexusUrl: answers.nexusUrl.replace(/\/$/, ''), // Remove trailing slash
+        downloadDir: answers.downloadDir.replace('~', process.env.HOME || ''),
+    };
+}
+function getStatus(tool, downloaded) {
+    const record = downloaded[tool.name];
+    if (!record) {
+        return { status: 'new', downloadedVersion: null };
+    }
+    if (record.version !== tool.version) {
+        return { status: 'update', downloadedVersion: record.version };
+    }
+    return { status: 'current', downloadedVersion: record.version };
+}
+export async function promptToolSelection(tools, downloaded, generatedAt) {
+    const choices = tools.map((tool) => {
+        const { status, downloadedVersion } = getStatus(tool, downloaded);
+        return {
+            ...tool,
+            status,
+            downloadedVersion,
+        };
+    });
+    console.log(chalk.bold(`\nrelease-radar-cli`));
+    console.log(chalk.gray(`Last updated: ${new Date(generatedAt).toLocaleString()}\n`));
+    // Display table
+    console.log(chalk.bold('  Tool               Latest       Downloaded   Status'));
+    console.log(chalk.gray('─'.repeat(60)));
+    choices.forEach((choice) => {
+        const downloadedStr = choice.downloadedVersion ?? '-';
+        let statusStr;
+        switch (choice.status) {
+            case 'new':
+                statusStr = chalk.blue('NEW');
+                break;
+            case 'update':
+                statusStr = chalk.yellow('UPDATE');
+                break;
+            case 'current':
+                statusStr = chalk.green('✓');
+                break;
+        }
+        console.log(`  ${choice.displayName.padEnd(18)} ${choice.version.padEnd(12)} ${downloadedStr.padEnd(12)} ${statusStr}`);
+    });
+    console.log('');
+    const { selected } = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'selected',
+            message: 'Select tools to download:',
+            choices: choices.map((choice) => ({
+                name: `${choice.displayName} ${choice.version}`,
+                value: choice,
+                checked: choice.status !== 'current',
+            })),
+        },
+    ]);
+    return selected;
+}

package/dist/updater.d.ts

@@ -0,0 +1 @@
+export declare function checkAndUpdate(): Promise<boolean>;

package/dist/updater.js

@@ -0,0 +1,51 @@
+import { execSync, spawn } from 'child_process';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+function getCurrentVersion() {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = join(__dirname, '..', 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    return pkg.version;
+}
+function getLatestVersion() {
+    try {
+        const result = execSync('npm view @lvnt/release-radar-cli version', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return result.trim();
+    }
+    catch {
+        return null;
+    }
+}
+export async function checkAndUpdate() {
+    const current = getCurrentVersion();
+    const latest = getLatestVersion();
+    if (!latest) {
+        // Can't reach npm registry, continue with current
+        return false;
+    }
+    if (current === latest) {
+        return false;
+    }
+    console.log(`Updating from ${current} to ${latest}...`);
+    try {
+        execSync('npm update -g @lvnt/release-radar-cli', {
+            stdio: 'inherit',
+        });
+        console.log('Update complete. Restarting...\n');
+        // Restart self
+        const child = spawn(process.argv[0], process.argv.slice(1), {
+            detached: true,
+            stdio: 'inherit',
+        });
+        child.unref();
+        process.exit(0);
+    }
+    catch (error) {
+        console.error('Update failed, continuing with current version');
+        return false;
+    }
+}

package/dist/versions.d.ts

@@ -0,0 +1,2 @@
+import type { VersionsJson } from './types.js';
+export declare function loadVersions(): VersionsJson;

package/dist/versions.js

@@ -0,0 +1,10 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+export function loadVersions() {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    // In dist/, versions.json is at package root
+    const versionsPath = join(__dirname, '..', 'versions.json');
+    const content = readFileSync(versionsPath, 'utf-8');
+    return JSON.parse(content);
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@lvnt/release-radar-cli",
+  "version": "0.1.0",
+  "description": "Interactive CLI for downloading tools through Nexus proxy",
+  "main": "dist/index.js",
+  "bin": {
+    "release-radar-cli": "bin/release-radar-cli.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "versions.json"
+  ],
+  "keywords": [
+    "release",
+    "download",
+    "nexus",
+    "cli"
+  ],
+  "author": "lvnt",
+  "license": "ISC",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "inquirer": "^9.2.12"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.10.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.1.0"
+  }
+}

package/versions.json

@@ -0,0 +1,21 @@
+{
+  "generatedAt": "2026-01-24T10:00:00Z",
+  "tools": [
+    {
+      "name": "Ninja",
+      "displayName": "Ninja",
+      "version": "1.12.0",
+      "publishedAt": "2026-01-20T00:00:00Z",
+      "downloadUrl": "{{NEXUS_URL}}/github.com/ninja-build/ninja/releases/download/v1.12.0/ninja-linux.zip",
+      "filename": "ninja-1.12.0-linux.zip"
+    },
+    {
+      "name": "CMake",
+      "displayName": "CMake",
+      "version": "3.28.1",
+      "publishedAt": "2026-01-18T00:00:00Z",
+      "downloadUrl": "{{NEXUS_URL}}/github.com/Kitware/CMake/releases/download/v3.28.1/cmake-3.28.1-linux-x86_64.tar.gz",
+      "filename": "cmake-3.28.1-linux-x86_64.tar.gz"
+    }
+  ]
+}