@lvnt/release-radar 1.6.2 → 1.7.0

package/cli/bin/release-radar-cli.js

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

package/cli/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@lvnt/release-radar-cli",
+  "version": "0.2.2",
+  "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/cli/src/config.test.ts

@@ -0,0 +1,48 @@
+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: string;
+  let configManager: 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/cli/src/config.ts

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

package/cli/src/downloader.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import { buildWgetCommand, replaceNexusUrl, buildNpmUpdateCommand } 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"');
+    });
+  });
+
+  describe('buildNpmUpdateCommand', () => {
+    it('builds correct npm update command', () => {
+      const cmd = buildNpmUpdateCommand('ralphy-cli');
+      expect(cmd).toBe('npm update -g ralphy-cli');
+    });
+  });
+});

package/cli/src/downloader.ts

@@ -0,0 +1,56 @@
+import { execSync } from 'child_process';
+import { join } from 'path';
+import { existsSync, mkdirSync } from 'fs';
+
+export function replaceNexusUrl(url: string, nexusUrl: string): string {
+  return url.replace('{{NEXUS_URL}}', nexusUrl);
+}
+
+export function buildWgetCommand(url: string, outputPath: string): string {
+  return `wget -O "${outputPath}" "${url}"`;
+}
+
+export interface DownloadResult {
+  success: boolean;
+  error?: string;
+}
+
+export function downloadFile(
+  url: string,
+  downloadDir: string,
+  filename: string,
+  nexusUrl: string
+): DownloadResult {
+  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 };
+  }
+}
+
+export function buildNpmUpdateCommand(packageName: string): string {
+  return `npm update -g ${packageName}`;
+}
+
+export function updateNpmPackage(packageName: string): DownloadResult {
+  const command = buildNpmUpdateCommand(packageName);
+
+  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/cli/src/index.ts

@@ -0,0 +1,170 @@
+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, updateNpmPackage } from './downloader.js';
+import { promptSetup, promptToolSelection, type ToolChoice } from './ui.js';
+import { isNpmTool } from './types.js';
+
+async function showStatus(): Promise<void> {
+  const tracker = new DownloadTracker();
+  const versions = loadVersions();
+  const downloaded = tracker.getAll();
+
+  console.log(chalk.bold('\nTool Status:\n'));
+  console.log(chalk.bold('  Tool               Latest       Downloaded   Status   Type'));
+  console.log(chalk.gray('─'.repeat(70)));
+
+  for (const tool of versions.tools) {
+    const record = downloaded[tool.name];
+    const downloadedVersion = record?.version ?? '-';
+
+    let status: string;
+    if (!record) {
+      status = chalk.blue('NEW');
+    } else if (record.version !== tool.version) {
+      status = chalk.yellow('UPDATE');
+    } else {
+      status = chalk.green('✓');
+    }
+
+    const typeStr = isNpmTool(tool) ? chalk.magenta('npm') : chalk.cyan('wget');
+    console.log(`  ${tool.displayName.padEnd(18)} ${tool.version.padEnd(12)} ${downloadedVersion.padEnd(12)} ${status.padEnd(12)} ${typeStr}`);
+  }
+  console.log('');
+}
+
+async function runConfig(): Promise<void> {
+  const configManager = new ConfigManager();
+  const config = await promptSetup();
+  configManager.save(config);
+  console.log(chalk.green('\nConfiguration saved!'));
+}
+
+async function runInteractive(): Promise<void> {
+  const configManager = new ConfigManager();
+  const tracker = new DownloadTracker();
+
+  // Check for updates first (before any prompts) unless --skip-update is passed
+  const skipUpdate = process.argv.includes('--skip-update');
+  if (!skipUpdate) {
+    await checkAndUpdate();
+  }
+
+  // First run setup
+  if (!configManager.isConfigured()) {
+    const config = await promptSetup();
+    configManager.save(config);
+    console.log(chalk.green('\nConfiguration saved!\n'));
+  }
+
+  // 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/update selected tools
+  console.log('');
+  const successes: { name: string; version: string; type: 'download' | 'npm' }[] = [];
+  const failures: { name: string; version: string; error: string }[] = [];
+
+  for (const tool of selected) {
+    if (tool.type === 'npm') {
+      console.log(chalk.bold(`Updating npm package ${tool.displayName} (${tool.package})...`));
+      const result = updateNpmPackage(tool.package);
+
+      if (result.success) {
+        tracker.recordDownload(tool.name, tool.version, `npm:${tool.package}`);
+        console.log(chalk.green(`  Updated ${tool.package} to ${tool.version} ✓\n`));
+        successes.push({ name: tool.displayName, version: tool.version, type: 'npm' });
+      } else {
+        console.log(chalk.red(`  Failed: ${result.error}\n`));
+        failures.push({ name: tool.displayName, version: tool.version, error: result.error || 'Unknown error' });
+      }
+    } else {
+      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`));
+        successes.push({ name: tool.displayName, version: tool.version, type: 'download' });
+      } else {
+        console.log(chalk.red(`  Failed: ${result.error}\n`));
+        failures.push({ name: tool.displayName, version: tool.version, error: result.error || 'Unknown error' });
+      }
+    }
+  }
+
+  // Summary report
+  console.log(chalk.bold('─'.repeat(50)));
+  console.log(chalk.bold('Summary\n'));
+
+  if (successes.length > 0) {
+    console.log(chalk.green(`✓ ${successes.length} succeeded:`));
+    for (const s of successes) {
+      console.log(chalk.green(`  • ${s.name} ${s.version}`));
+    }
+  }
+
+  if (failures.length > 0) {
+    console.log(chalk.red(`\n✗ ${failures.length} failed:`));
+    for (const f of failures) {
+      console.log(chalk.red(`  • ${f.name} ${f.version}: ${f.error}`));
+    }
+  }
+
+  console.log('');
+  if (failures.length === 0) {
+    console.log(chalk.green('All downloads completed successfully!'));
+  } else if (successes.length === 0) {
+    console.log(chalk.red('All downloads failed.'));
+  } else {
+    console.log(chalk.yellow(`Completed with ${failures.length} failure(s).`));
+  }
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2).filter(arg => !arg.startsWith('--'));
+  const command = args[0];
+
+  switch (command) {
+    case 'status':
+      await showStatus();
+      break;
+    case 'config':
+      await runConfig();
+      break;
+    default:
+      // Check if stdin is a TTY for interactive mode
+      if (!process.stdin.isTTY) {
+        console.error(chalk.red('Error: Interactive mode requires a TTY. Use "status" command for non-interactive use.'));
+        process.exit(1);
+      }
+      await runInteractive();
+      break;
+  }
+}
+
+main().catch((error) => {
+  console.error(chalk.red('Error:'), error.message);
+  process.exit(1);
+});

package/cli/src/tracker.test.ts

@@ -0,0 +1,40 @@
+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: string;
+  let tracker: DownloadTracker;
+
+  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/cli/src/tracker.ts

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

package/cli/src/types.ts

@@ -0,0 +1,34 @@
+export interface VersionsJsonToolDownload {
+  name: string;
+  displayName: string;
+  version: string;
+  publishedAt: string;
+  type?: 'download';  // default
+  downloadUrl: string;
+  filename: string;
+}
+
+export interface VersionsJsonToolNpm {
+  name: string;
+  displayName: string;
+  version: string;
+  publishedAt: string;
+  type: 'npm';
+  package: string;
+}
+
+export type VersionsJsonTool = VersionsJsonToolDownload | VersionsJsonToolNpm;
+
+export interface VersionsJson {
+  generatedAt: string;
+  tools: VersionsJsonTool[];
+}
+
+// Type guards
+export function isNpmTool(tool: VersionsJsonTool): tool is VersionsJsonToolNpm {
+  return tool.type === 'npm';
+}
+
+export function isDownloadTool(tool: VersionsJsonTool): tool is VersionsJsonToolDownload {
+  return tool.type !== 'npm';
+}

package/cli/src/ui.ts

@@ -0,0 +1,149 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import type { VersionsJsonTool } from './types.js';
+import { isNpmTool } from './types.js';
+import type { DownloadedState } from './tracker.js';
+import type { CliConfig } from './config.js';
+
+export async function promptSetup(): Promise<CliConfig> {
+  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: string) => {
+        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: string) => input.trim() ? true : 'Directory is required',
+    },
+  ]);
+
+  return {
+    nexusUrl: answers.nexusUrl.replace(/\/$/, ''), // Remove trailing slash
+    downloadDir: answers.downloadDir.replace('~', process.env.HOME || ''),
+  };
+}
+
+interface ToolChoiceBase {
+  name: string;
+  displayName: string;
+  version: string;
+  status: 'new' | 'update' | 'current';
+  downloadedVersion: string | null;
+}
+
+interface ToolChoiceDownload extends ToolChoiceBase {
+  type: 'download';
+  downloadUrl: string;
+  filename: string;
+}
+
+interface ToolChoiceNpm extends ToolChoiceBase {
+  type: 'npm';
+  package: string;
+}
+
+export type ToolChoice = ToolChoiceDownload | ToolChoiceNpm;
+
+function getStatus(
+  tool: VersionsJsonTool,
+  downloaded: DownloadedState
+): { status: 'new' | 'update' | 'current'; downloadedVersion: string | null } {
+  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 };
+}
+
+function createToolChoice(tool: VersionsJsonTool, downloaded: DownloadedState): ToolChoice {
+  const { status, downloadedVersion } = getStatus(tool, downloaded);
+  const base = {
+    name: tool.name,
+    displayName: tool.displayName,
+    version: tool.version,
+    status,
+    downloadedVersion,
+  };
+
+  if (isNpmTool(tool)) {
+    return {
+      ...base,
+      type: 'npm',
+      package: tool.package,
+    };
+  } else {
+    return {
+      ...base,
+      type: 'download',
+      downloadUrl: tool.downloadUrl,
+      filename: tool.filename,
+    };
+  }
+}
+
+export async function promptToolSelection(
+  tools: VersionsJsonTool[],
+  downloaded: DownloadedState,
+  generatedAt: string
+): Promise<ToolChoice[]> {
+  const choices: ToolChoice[] = tools.map((tool) => createToolChoice(tool, downloaded));
+
+  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   Type'));
+  console.log(chalk.gray('─'.repeat(70)));
+
+  choices.forEach((choice) => {
+    const downloadedStr = choice.downloadedVersion ?? '-';
+    let statusStr: string;
+    switch (choice.status) {
+      case 'new':
+        statusStr = chalk.blue('NEW');
+        break;
+      case 'update':
+        statusStr = chalk.yellow('UPDATE');
+        break;
+      case 'current':
+        statusStr = chalk.green('✓');
+        break;
+    }
+    const typeStr = choice.type === 'npm' ? chalk.magenta('npm') : chalk.cyan('wget');
+    console.log(
+      `  ${choice.displayName.padEnd(18)} ${choice.version.padEnd(12)} ${downloadedStr.padEnd(12)} ${statusStr.padEnd(12)} ${typeStr}`
+    );
+  });
+
+  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/cli/src/updater.ts

@@ -0,0 +1,61 @@
+import { execSync, spawn } from 'child_process';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+function getCurrentVersion(): string {
+  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(): string | null {
+  try {
+    const result = execSync('npm view @lvnt/release-radar-cli version', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 10000, // 10 second timeout
+    });
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+
+export async function checkAndUpdate(): Promise<boolean> {
+  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 {
+    // Use pipe instead of inherit to avoid messing with terminal state
+    const result = execSync('npm update -g @lvnt/release-radar-cli', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    if (result) console.log(result);
+    console.log('Update complete. Restarting...\n');
+
+    // Restart self with a fresh terminal
+    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/cli/src/versions.ts

@@ -0,0 +1,12 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import type { VersionsJson } from './types.js';
+
+export function loadVersions(): VersionsJson {
+  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/cli/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/cli/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"
+    }
+  ]
+}

package/dist/index.js

@@ -3,7 +3,7 @@ import { config } from 'dotenv';
 config();
 import TelegramBot from 'node-telegram-bot-api';
 import cron from 'node-cron';
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, cpSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { Storage } from './storage.js';
@@ -49,18 +49,30 @@ try {
 catch {
     console.log('No downloads.json found, CLI generation disabled');
 }
-// Data directory - use package root for now, could be made configurable
-const DATA_DIR = join(PKG_ROOT, 'data');
+// Data directory - use ~/.release-radar for user-writable storage
+const HOME_DIR = process.env.HOME || process.env.USERPROFILE || '/tmp';
+const DATA_DIR = process.env.RELEASE_RADAR_DATA_DIR || join(HOME_DIR, '.release-radar');
 if (!existsSync(DATA_DIR)) {
     mkdirSync(DATA_DIR, { recursive: true });
 }
 console.log(`Data directory: ${DATA_DIR}`);
+// Copy cli/ to user directory for publishing (needs to be writable)
+const PKG_CLI_DIR = join(PKG_ROOT, 'cli');
+const USER_CLI_DIR = join(DATA_DIR, 'cli');
+if (existsSync(PKG_CLI_DIR) && !existsSync(USER_CLI_DIR)) {
+    console.log(`Copying CLI source to ${USER_CLI_DIR}...`);
+    cpSync(PKG_CLI_DIR, USER_CLI_DIR, { recursive: true });
+    console.log('CLI source copied successfully');
+}
+else if (existsSync(USER_CLI_DIR)) {
+    console.log(`CLI source directory: ${USER_CLI_DIR}`);
+}
 // Initialize components
 const bot = new TelegramBot(BOT_TOKEN, { polling: true });
 const storage = new Storage(join(DATA_DIR, 'versions.json'));
 const notifier = new Notifier(bot, validatedChatId);
 const checker = new Checker(configData.tools, storage, notifier);
-const cliPublisher = new CliPublisher(downloadsConfig, join(PKG_ROOT, 'cli'));
+const cliPublisher = new CliPublisher(downloadsConfig, USER_CLI_DIR);
 // Track scheduled task for rescheduling
 let scheduledTask = null;
 let lastCheckTime = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvnt/release-radar",
-  "version": "1.6.2",
+  "version": "1.7.0",
   "description": "Monitor tool versions and notify via Telegram when updates are detected",
   "main": "dist/index.js",
   "bin": {
@@ -40,6 +40,11 @@
     "dist",
     "bin",
     "config",
+    "cli/src",
+    "cli/bin",
+    "cli/package.json",
+    "cli/tsconfig.json",
+    "cli/versions.json",
     ".env.example"
   ],
   "dependencies": {