@lvnt/release-radar 1.8.2 → 1.9.0

package/README.md

@@ -113,10 +113,12 @@ TELEGRAM_CHAT_ID=your_chat_id_here
 
 ### Tools Configuration
 
-Edit `config/tools.json` to add/remove tools:
+Edit `config/tools.json` to add/remove tools and configure scheduling:
 
 ```json
 {
+  "scheduleMode": "daily",
+  "dailyCheckTime": "06:00",
   "checkIntervalHours": 6,
   "tools": [
     {
@@ -128,6 +130,14 @@ Edit `config/tools.json` to add/remove tools:
 }
 ```
 
+#### Schedule Options
+
+| Field | Values | Description |
+|-------|--------|-------------|
+| `scheduleMode` | `"daily"` or `"interval"` | Check once per day or every N hours |
+| `dailyCheckTime` | `"HH:MM"` | Time for daily check (24-hour format, e.g., `"06:00"`) |
+| `checkIntervalHours` | `1-24` | Hours between checks (interval mode) |
+
 #### Tool Types
 
 | Type | Required Fields | Description |
@@ -169,8 +179,11 @@ Placeholders:
 |---------|-------------|
 | `/check` | Manually trigger version check (auto-publishes CLI if updates found) |
 | `/status` | Show all tracked versions + last/next check times |
-| `/interval` | Show current check interval |
-| `/setinterval <hours>` | Set check interval (1-24 hours) |
+| `/schedule` | Show current schedule mode and next check time |
+| `/settime <HH:MM>` | Set daily check time (e.g., `/settime 06:00`) and switch to daily mode |
+| `/setmode <daily\|interval>` | Switch between daily and interval modes |
+| `/interval` | Show current check interval (interval mode) |
+| `/setinterval <hours>` | Set check interval (1-24 hours) and switch to interval mode |
 | `/generate` | Generate versions.json file locally |
 | `/clipreview` | Preview tools/versions that will be included in CLI |
 | `/publishcli` | Manually publish CLI with current tracked versions |

package/cli/src/ui.ts

@@ -132,21 +132,28 @@ export interface TableRow {
   downloadedVersion: string;
   status: 'new' | 'update' | 'current';
   type: 'npm' | 'download';
+  category: 'tool' | 'vscode-extension';
 }
 
-export function renderTable(rows: TableRow[]): void {
-  // Calculate dynamic column widths
-  const colWidths = {
+interface ColWidths {
+  tool: number;
+  latest: number;
+  downloaded: number;
+  status: number;
+  type: number;
+}
+
+function calculateColWidths(rows: TableRow[]): ColWidths {
+  return {
     tool: Math.max(4, ...rows.map(r => r.displayName.length)) + 2,
     latest: Math.max(6, ...rows.map(r => r.version.length)) + 2,
     downloaded: Math.max(10, ...rows.map(r => r.downloadedVersion.length)) + 2,
     status: 8,
     type: 4,
   };
+}
 
-  const totalWidth = colWidths.tool + colWidths.latest + colWidths.downloaded + colWidths.status + colWidths.type + 2;
-
-  // Header
+function renderTableHeader(colWidths: ColWidths): void {
   console.log(chalk.bold(
     '  ' +
     'Tool'.padEnd(colWidths.tool) +
@@ -155,40 +162,76 @@ export function renderTable(rows: TableRow[]): void {
     'Status'.padEnd(colWidths.status) +
     'Type'
   ));
+  const totalWidth = colWidths.tool + colWidths.latest + colWidths.downloaded + colWidths.status + colWidths.type + 2;
+  console.log(chalk.gray('─'.repeat(totalWidth)));
+}
+
+function renderTableRow(row: TableRow, colWidths: ColWidths): void {
+  let statusText: string;
+  let statusColored: string;
+  switch (row.status) {
+    case 'new':
+      statusText = 'NEW'.padEnd(colWidths.status);
+      statusColored = chalk.blue(statusText);
+      break;
+    case 'update':
+      statusText = 'UPDATE'.padEnd(colWidths.status);
+      statusColored = chalk.yellow(statusText);
+      break;
+    case 'current':
+      statusText = '✓'.padEnd(colWidths.status);
+      statusColored = chalk.green(statusText);
+      break;
+  }
+  const typeStr = row.type === 'npm' ? chalk.magenta('npm') : chalk.cyan('wget');
+
+  console.log(
+    '  ' +
+    row.displayName.padEnd(colWidths.tool) +
+    row.version.padEnd(colWidths.latest) +
+    row.downloadedVersion.padEnd(colWidths.downloaded) +
+    statusColored +
+    typeStr
+  );
+}
+
+function renderGroupHeader(title: string, colWidths: ColWidths): void {
+  const totalWidth = colWidths.tool + colWidths.latest + colWidths.downloaded + colWidths.status + colWidths.type + 2;
+  console.log('');
+  console.log(chalk.bold.underline(`  ${title}`));
   console.log(chalk.gray('─'.repeat(totalWidth)));
+}
+
+export function renderTable(rows: TableRow[]): void {
+  const colWidths = calculateColWidths(rows);
 
-  // Rows
-  for (const row of rows) {
-    // Pad plain text BEFORE applying colors (chalk adds invisible ANSI codes)
-    let statusText: string;
-    let statusColored: string;
-    switch (row.status) {
-      case 'new':
-        statusText = 'NEW'.padEnd(colWidths.status);
-        statusColored = chalk.blue(statusText);
-        break;
-      case 'update':
-        statusText = 'UPDATE'.padEnd(colWidths.status);
-        statusColored = chalk.yellow(statusText);
-        break;
-      case 'current':
-        statusText = '✓'.padEnd(colWidths.status);
-        statusColored = chalk.green(statusText);
-        break;
+  // Group rows by category
+  const tools = rows.filter(r => r.category === 'tool');
+  const extensions = rows.filter(r => r.category === 'vscode-extension');
+
+  // Render tools first
+  if (tools.length > 0) {
+    renderTableHeader(colWidths);
+    for (const row of tools) {
+      renderTableRow(row, colWidths);
+    }
+  }
+
+  // Render VSCode extensions as a separate group
+  if (extensions.length > 0) {
+    renderGroupHeader('VSCode Extensions', colWidths);
+    for (const row of extensions) {
+      renderTableRow(row, colWidths);
     }
-    const typeStr = row.type === 'npm' ? chalk.magenta('npm') : chalk.cyan('wget');
-
-    console.log(
-      '  ' +
-      row.displayName.padEnd(colWidths.tool) +
-      row.version.padEnd(colWidths.latest) +
-      row.downloadedVersion.padEnd(colWidths.downloaded) +
-      statusColored +
-      typeStr
-    );
   }
 }
 
+function isVscodeExtension(tool: VersionsJsonTool): boolean {
+  if (isNpmTool(tool)) return false;
+  // Check if filename ends with .vsix
+  return tool.filename.toLowerCase().endsWith('.vsix');
+}
+
 export async function promptToolSelection(
   tools: VersionsJsonTool[],
   downloaded: DownloadedState,
@@ -199,24 +242,30 @@ export async function promptToolSelection(
   console.log(chalk.bold(`\nrelease-radar-cli`));
   console.log(chalk.gray(`Last updated: ${new Date(generatedAt).toLocaleString()}\n`));
 
-  // Convert to table rows and display
-  const rows: TableRow[] = choices.map(choice => ({
-    displayName: choice.displayName,
-    version: choice.version,
-    downloadedVersion: choice.downloadedVersion ?? '-',
-    status: choice.status,
-    type: choice.type === 'npm' ? 'npm' : 'download',
+  // Convert to table rows with category and display
+  const rows: TableRow[] = tools.map((tool, i) => ({
+    displayName: choices[i].displayName,
+    version: choices[i].version,
+    downloadedVersion: choices[i].downloadedVersion ?? '-',
+    status: choices[i].status,
+    type: choices[i].type === 'npm' ? 'npm' : 'download',
+    category: isVscodeExtension(tool) ? 'vscode-extension' : 'tool',
   }));
 
   renderTable(rows);
   console.log('');
 
+  // Sort choices to match displayed order (tools first, then extensions)
+  const toolChoices = choices.filter((_, i) => !isVscodeExtension(tools[i]));
+  const extensionChoices = choices.filter((_, i) => isVscodeExtension(tools[i]));
+  const sortedChoices = [...toolChoices, ...extensionChoices];
+
   const { selected } = await inquirer.prompt([
     {
       type: 'checkbox',
       name: 'selected',
       message: 'Select tools to download:',
-      choices: choices.map((choice) => ({
+      choices: sortedChoices.map((choice) => ({
         name: `${choice.displayName} ${choice.version}`,
         value: choice,
         checked: choice.status !== 'current',

package/config/tools.json

@@ -1,5 +1,7 @@
 {
-  "checkIntervalHours": 1,
+  "checkIntervalHours": 6,
+  "scheduleMode": "daily",
+  "dailyCheckTime": "06:00",
   "tools": [
     {
       "name": "VSCode",

package/dist/asset-mirror.d.ts

@@ -4,14 +4,34 @@ export interface MirrorResult {
     downloadUrl?: string;
     error?: string;
 }
+export interface MirrorItem {
+    toolName: string;
+    version: string;
+    config: MirrorConfig;
+    filenameTemplate: string;
+}
+export interface BatchMirrorResult {
+    tag: string;
+    results: Map<string, MirrorResult>;
+}
 export declare class AssetMirror {
     private repo;
+    /**
+     * Mirror a single tool (legacy method, still used for /mirror command)
+     */
     mirror(toolName: string, version: string, config: MirrorConfig, filenameTemplate: string): Promise<MirrorResult>;
+    /**
+     * Mirror multiple tools into a single batch release
+     */
+    mirrorBatch(items: MirrorItem[]): Promise<BatchMirrorResult>;
     buildTag(toolName: string, version: string): string;
+    buildBatchTag(): string;
+    private findExistingAsset;
     releaseExists(tag: string): Promise<boolean>;
     private applyVersion;
     private getSourceUrl;
     private getMarketplaceVsixUrl;
     private downloadFile;
     private createRelease;
+    private createBatchRelease;
 }

package/dist/asset-mirror.js

@@ -5,6 +5,9 @@ import { tmpdir } from 'os';
 import { join } from 'path';
 export class AssetMirror {
     repo = 'lvntbkdmr/apps';
+    /**
+     * Mirror a single tool (legacy method, still used for /mirror command)
+     */
     async mirror(toolName, version, config, filenameTemplate) {
         const tag = this.buildTag(toolName, version);
         const filename = this.applyVersion(filenameTemplate, version);
@@ -38,10 +41,86 @@ export class AssetMirror {
             return { success: false, error: message };
         }
     }
+    /**
+     * Mirror multiple tools into a single batch release
+     */
+    async mirrorBatch(items) {
+        const tag = this.buildBatchTag();
+        const results = new Map();
+        const downloadedFiles = [];
+        console.log(`[AssetMirror] Starting batch mirror for ${items.length} items, tag: ${tag}`);
+        // Download all files first
+        for (const item of items) {
+            const filename = this.applyVersion(item.filenameTemplate, item.version);
+            const downloadUrl = `github.com/${this.repo}/releases/download/${tag}/${filename}`;
+            try {
+                // Check if this specific file already exists in any release
+                const existingUrl = await this.findExistingAsset(item.toolName, item.version, filename);
+                if (existingUrl) {
+                    console.log(`[AssetMirror] ${item.toolName} v${item.version} already mirrored, skipping`);
+                    results.set(item.toolName, { success: true, downloadUrl: existingUrl });
+                    continue;
+                }
+                console.log(`[AssetMirror] Getting source URL for ${item.toolName} v${item.version}...`);
+                const sourceUrl = await this.getSourceUrl(item.config, item.version);
+                const tempPath = join(tmpdir(), filename);
+                console.log(`[AssetMirror] Downloading to ${tempPath}...`);
+                await this.downloadFile(sourceUrl, tempPath);
+                downloadedFiles.push({ path: tempPath, filename });
+                results.set(item.toolName, { success: true, downloadUrl });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(`[AssetMirror] Failed to download ${item.toolName}: ${message}`);
+                results.set(item.toolName, { success: false, error: message });
+            }
+        }
+        // Create single release with all downloaded files
+        if (downloadedFiles.length > 0) {
+            try {
+                console.log(`[AssetMirror] Creating batch release ${tag} with ${downloadedFiles.length} assets...`);
+                await this.createBatchRelease(tag, downloadedFiles, items);
+                console.log(`[AssetMirror] Batch release created successfully`);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(`[AssetMirror] Failed to create batch release: ${message}`);
+                // Mark all as failed if release creation fails
+                for (const file of downloadedFiles) {
+                    const toolName = items.find(i => this.applyVersion(i.filenameTemplate, i.version) === file.filename)?.toolName;
+                    if (toolName) {
+                        results.set(toolName, { success: false, error: message });
+                    }
+                }
+            }
+            // Cleanup temp files
+            for (const file of downloadedFiles) {
+                if (existsSync(file.path)) {
+                    unlinkSync(file.path);
+                }
+            }
+        }
+        return { tag, results };
+    }
     buildTag(toolName, version) {
         const kebab = toolName.toLowerCase().replace(/\s+/g, '-');
         return `${kebab}-v${version}`;
     }
+    buildBatchTag() {
+        const now = new Date();
+        const date = now.toISOString().split('T')[0]; // YYYY-MM-DD
+        const time = now.toTimeString().split(' ')[0].replace(/:/g, ''); // HHMMSS
+        return `batch-${date}-${time}`;
+    }
+    async findExistingAsset(toolName, version, filename) {
+        // Check legacy per-tool release first
+        const legacyTag = this.buildTag(toolName, version);
+        if (await this.releaseExists(legacyTag)) {
+            return `github.com/${this.repo}/releases/download/${legacyTag}/${filename}`;
+        }
+        // Could also search batch releases, but for simplicity we skip if not in legacy
+        return null;
+    }
     async releaseExists(tag) {
         try {
             execSync(`gh release view ${tag} --repo ${this.repo}`, {
@@ -118,4 +197,23 @@ export class AssetMirror {
         execSync(`gh release create "${tag}" "${filePath}#${filename}" ` +
             `--repo ${this.repo} --title "${title}" --notes "${notes}"`, { encoding: 'utf-8', timeout: 300000 });
     }
+    async createBatchRelease(tag, files, items) {
+        const date = new Date().toLocaleDateString('en-US', {
+            year: 'numeric',
+            month: 'long',
+            day: 'numeric',
+        });
+        const title = `Updates ${date}`;
+        // Build release notes listing all tools
+        const toolsList = items
+            .filter(item => files.some(f => f.filename === this.applyVersion(item.filenameTemplate, item.version)))
+            .map(item => `- ${item.toolName} ${item.version}`)
+            .join('\n');
+        const notes = `Mirrored for Nexus proxy access.\n\n**Included:**\n${toolsList}`;
+        // Build file arguments for gh release create
+        const fileArgs = files.map(f => `"${f.path}#${f.filename}"`).join(' ');
+        execSync(`gh release create "${tag}" ${fileArgs} ` +
+            `--repo ${this.repo} --title "${title}" --notes "${notes}"`, { encoding: 'utf-8', timeout: 600000 } // 10 minutes for multiple uploads
+        );
+    }
 }

package/dist/checker.d.ts

@@ -13,5 +13,5 @@ export declare class Checker {
         hasUpdates: boolean;
         updateCount: number;
     }>;
-    private mirrorIfConfigured;
+    private getMirrorItem;
 }

package/dist/checker.js

@@ -15,6 +15,7 @@ export class Checker {
     async checkAll() {
         const updates = [];
         const failures = [];
+        const mirrorItems = [];
         for (const tool of this.tools) {
             try {
                 const newVersion = await fetchVersion(tool);
@@ -26,8 +27,11 @@ export class Checker {
                 else if (oldVersion !== newVersion) {
                     updates.push({ name: tool.name, oldVersion, newVersion });
                     this.storage.setVersion(tool.name, newVersion);
-                    // Mirror asset if configured
-                    await this.mirrorIfConfigured(tool.name, newVersion);
+                    // Collect mirror items for batch processing
+                    const mirrorItem = this.getMirrorItem(tool.name, newVersion);
+                    if (mirrorItem) {
+                        mirrorItems.push(mirrorItem);
+                    }
                 }
             }
             catch (error) {
@@ -35,22 +39,34 @@ export class Checker {
                 failures.push({ name: tool.name, error: message });
             }
         }
+        // Batch mirror all updated assets
+        if (mirrorItems.length > 0 && this.assetMirror) {
+            const batchResult = await this.assetMirror.mirrorBatch(mirrorItems);
+            // Store mirror URLs for successful items
+            for (const [toolName, result] of batchResult.results) {
+                if (result.success && result.downloadUrl) {
+                    this.storage.setMirrorUrl(toolName, result.downloadUrl);
+                }
+            }
+        }
         await this.notifier.sendBatchedUpdates(updates);
         await this.notifier.sendBatchedFailures(failures);
         return { hasUpdates: updates.length > 0, updateCount: updates.length };
     }
-    async mirrorIfConfigured(toolName, version) {
-        if (!this.assetMirror || !this.downloadsConfig)
-            return;
+    getMirrorItem(toolName, version) {
+        if (!this.downloadsConfig)
+            return null;
         const downloadConfig = this.downloadsConfig[toolName];
         if (!downloadConfig || downloadConfig.type === 'npm')
-            return;
+            return null;
         const urlConfig = downloadConfig;
         if (!urlConfig.mirror)
-            return;
-        const result = await this.assetMirror.mirror(toolName, version, urlConfig.mirror, urlConfig.filename);
-        if (result.success && result.downloadUrl) {
-            this.storage.setMirrorUrl(toolName, result.downloadUrl);
-        }
+            return null;
+        return {
+            toolName,
+            version,
+            config: urlConfig.mirror,
+            filenameTemplate: urlConfig.filename,
+        };
     }
 }

package/dist/checker.test.js

@@ -83,7 +83,10 @@ describe('Checker', () => {
         let downloadsConfig;
         beforeEach(() => {
             mockAssetMirror = {
-                mirror: vi.fn().mockResolvedValue({ success: true, downloadUrl: 'github.com/test/url' })
+                mirrorBatch: vi.fn().mockResolvedValue({
+                    tag: 'batch-2026-01-29-120000',
+                    results: new Map([['VSCode', { success: true, downloadUrl: 'github.com/test/url' }]])
+                })
             };
             downloadsConfig = {
                 'VSCode': {
@@ -106,7 +109,14 @@ describe('Checker', () => {
             mockStorage.getVersion.mockReturnValue('1.95.0');
             vi.mocked(fetchVersion).mockResolvedValue('1.96.0');
             await checkerWithMirror.checkAll();
-            expect(mockAssetMirror.mirror).toHaveBeenCalledWith('VSCode', '1.96.0', { sourceUrl: 'https://update.code.visualstudio.com/latest/win32-x64/stable' }, 'VSCode-{{VERSION}}-win-x64.msi');
+            expect(mockAssetMirror.mirrorBatch).toHaveBeenCalledWith([
+                {
+                    toolName: 'VSCode',
+                    version: '1.96.0',
+                    config: { sourceUrl: 'https://update.code.visualstudio.com/latest/win32-x64/stable' },
+                    filenameTemplate: 'VSCode-{{VERSION}}-win-x64.msi'
+                }
+            ]);
             expect(mockStorage.setMirrorUrl).toHaveBeenCalledWith('VSCode', 'github.com/test/url');
         });
         it('does not mirror when tool has no mirror config', async () => {
@@ -115,7 +125,8 @@ describe('Checker', () => {
             mockStorage.getVersion.mockReturnValue('1.11.0');
             vi.mocked(fetchVersion).mockResolvedValue('1.12.0');
             await checkerWithMirror.checkAll();
-            expect(mockAssetMirror.mirror).not.toHaveBeenCalled();
+            // mirrorBatch should not be called when no items have mirror config
+            expect(mockAssetMirror.mirrorBatch).not.toHaveBeenCalled();
         });
         it('does not mirror when version unchanged', async () => {
             const vscodeTool = { name: 'VSCode', type: 'custom', customFetcher: 'vscode' };
@@ -123,11 +134,14 @@ describe('Checker', () => {
             mockStorage.getVersion.mockReturnValue('1.96.0');
             vi.mocked(fetchVersion).mockResolvedValue('1.96.0');
             await checkerWithMirror.checkAll();
-            expect(mockAssetMirror.mirror).not.toHaveBeenCalled();
+            expect(mockAssetMirror.mirrorBatch).not.toHaveBeenCalled();
         });
         it('continues if mirror fails', async () => {
             const vscodeTool = { name: 'VSCode', type: 'custom', customFetcher: 'vscode' };
-            mockAssetMirror.mirror.mockResolvedValue({ success: false, error: 'network error' });
+            mockAssetMirror.mirrorBatch.mockResolvedValue({
+                tag: 'batch-2026-01-29-120000',
+                results: new Map([['VSCode', { success: false, error: 'network error' }]])
+            });
             const checkerWithMirror = new Checker([vscodeTool], mockStorage, mockNotifier, mockAssetMirror, downloadsConfig);
             mockStorage.getVersion.mockReturnValue('1.95.0');
             vi.mocked(fetchVersion).mockResolvedValue('1.96.0');

package/dist/index.js

@@ -108,7 +108,18 @@ const checker = new Checker(configData.tools, storage, notifier, assetMirror, do
 let scheduledTask = null;
 let lastCheckTime = null;
 let nextCheckTime = null;
-function calculateNextCheckTime(intervalHours) {
+// Parse HH:MM time string
+function parseTime(timeStr) {
+    const match = timeStr.match(/^(\d{1,2}):(\d{2})$/);
+    if (!match)
+        return null;
+    const hour = parseInt(match[1], 10);
+    const minute = parseInt(match[2], 10);
+    if (hour < 0 || hour > 23 || minute < 0 || minute > 59)
+        return null;
+    return { hour, minute };
+}
+function calculateNextCheckTimeInterval(intervalHours) {
     const now = new Date();
     const next = new Date(now);
     next.setMinutes(0, 0, 0);
@@ -118,28 +129,67 @@ function calculateNextCheckTime(intervalHours) {
     }
     return next;
 }
-function scheduleChecks(intervalHours) {
+function calculateNextCheckTimeDaily(timeStr) {
+    const parsed = parseTime(timeStr);
+    if (!parsed) {
+        // Fallback to 6am if invalid
+        return calculateNextCheckTimeDaily('06:00');
+    }
+    const now = new Date();
+    const next = new Date(now);
+    next.setHours(parsed.hour, parsed.minute, 0, 0);
+    // If the time has passed today, schedule for tomorrow
+    if (next <= now) {
+        next.setDate(next.getDate() + 1);
+    }
+    return next;
+}
+function calculateNextCheckTime() {
+    const mode = configData.scheduleMode || 'interval';
+    if (mode === 'daily') {
+        return calculateNextCheckTimeDaily(configData.dailyCheckTime || '06:00');
+    }
+    return calculateNextCheckTimeInterval(configData.checkIntervalHours);
+}
+async function runScheduledCheck() {
+    console.log(`[${new Date().toISOString()}] Running scheduled check`);
+    lastCheckTime = new Date();
+    const result = await checker.checkAll();
+    nextCheckTime = calculateNextCheckTime();
+    // Auto-publish CLI if updates were detected
+    if (result.hasUpdates && cliPublisher.isConfigured()) {
+        const state = storage.load();
+        const mirrorUrls = storage.getAllMirrorUrls();
+        const publishResult = await cliPublisher.publish(state.versions, mirrorUrls);
+        if (publishResult.success) {
+            await bot.sendMessage(validatedChatId, `📦 CLI published: v${publishResult.version}`);
+        }
+    }
+}
+function scheduleChecks() {
     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();
-        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 mirrorUrls = storage.getAllMirrorUrls();
-            const publishResult = await cliPublisher.publish(state.versions, mirrorUrls);
-            if (publishResult.success) {
-                await bot.sendMessage(validatedChatId, `📦 CLI published: v${publishResult.version}`);
-            }
-        }
-    });
-    console.log(`Scheduled checks every ${intervalHours} hours`);
+    const mode = configData.scheduleMode || 'interval';
+    let cronExpression;
+    if (mode === 'daily') {
+        const timeStr = configData.dailyCheckTime || '06:00';
+        const parsed = parseTime(timeStr);
+        const hour = parsed?.hour ?? 6;
+        const minute = parsed?.minute ?? 0;
+        cronExpression = `${minute} ${hour} * * *`;
+        console.log(`Scheduled daily check at ${timeStr}`);
+    }
+    else {
+        const intervalHours = configData.checkIntervalHours;
+        cronExpression = `0 */${intervalHours} * * *`;
+        console.log(`Scheduled checks every ${intervalHours} hours`);
+    }
+    nextCheckTime = calculateNextCheckTime();
+    scheduledTask = cron.schedule(cronExpression, runScheduledCheck);
+}
+function saveConfig() {
+    writeFileSync(CONFIG_PATH, JSON.stringify(configData, null, 2));
 }
 // Bot commands
 bot.onText(/\/check/, async (msg) => {
@@ -148,7 +198,7 @@ bot.onText(/\/check/, async (msg) => {
     await bot.sendMessage(validatedChatId, 'Checking for updates...');
     lastCheckTime = new Date();
     const result = await checker.checkAll();
-    nextCheckTime = calculateNextCheckTime(configData.checkIntervalHours);
+    nextCheckTime = calculateNextCheckTime();
     // Auto-publish CLI if updates were detected
     if (result.hasUpdates && cliPublisher.isConfigured()) {
         const state = storage.load();
@@ -213,12 +263,84 @@ bot.onText(/\/setinterval(?:\s+(\d+))?/, async (msg, match) => {
         await bot.sendMessage(validatedChatId, 'Interval must be between 1 and 24 hours');
         return;
     }
-    // Update config
+    // Update config (also switch to interval mode)
     configData.checkIntervalHours = hours;
-    writeFileSync(CONFIG_PATH, JSON.stringify(configData, null, 2));
+    configData.scheduleMode = 'interval';
+    saveConfig();
     // Reschedule
-    scheduleChecks(hours);
-    await bot.sendMessage(validatedChatId, `Check interval updated to every ${hours} hours`);
+    scheduleChecks();
+    await bot.sendMessage(validatedChatId, `Check interval updated to every ${hours} hours (interval mode)`);
+});
+// /schedule - show current schedule configuration
+bot.onText(/\/schedule$/, async (msg) => {
+    if (msg.chat.id.toString() !== validatedChatId)
+        return;
+    const mode = configData.scheduleMode || 'interval';
+    let message;
+    if (mode === 'daily') {
+        const time = configData.dailyCheckTime || '06:00';
+        message = `📅 Schedule: Daily at ${time}`;
+    }
+    else {
+        message = `🔄 Schedule: Every ${configData.checkIntervalHours} hours`;
+    }
+    // Add next check info
+    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(validatedChatId, message);
+});
+// /settime <HH:MM> - set daily check time
+bot.onText(/\/settime(?:\s+(.+))?/, async (msg, match) => {
+    if (msg.chat.id.toString() !== validatedChatId)
+        return;
+    const timeStr = match?.[1]?.trim();
+    if (!timeStr) {
+        await bot.sendMessage(validatedChatId, 'Usage: /settime <HH:MM>\nExample: /settime 06:00');
+        return;
+    }
+    const parsed = parseTime(timeStr);
+    if (!parsed) {
+        await bot.sendMessage(validatedChatId, 'Invalid time format. Use HH:MM (24-hour), e.g., 06:00 or 18:30');
+        return;
+    }
+    // Update config and switch to daily mode
+    configData.dailyCheckTime = timeStr;
+    configData.scheduleMode = 'daily';
+    saveConfig();
+    // Reschedule
+    scheduleChecks();
+    await bot.sendMessage(validatedChatId, `✅ Daily check scheduled at ${timeStr}`);
+});
+// /setmode <daily|interval> - switch schedule mode
+bot.onText(/\/setmode(?:\s+(.+))?/, async (msg, match) => {
+    if (msg.chat.id.toString() !== validatedChatId)
+        return;
+    const modeArg = match?.[1]?.trim().toLowerCase();
+    if (!modeArg || !['daily', 'interval'].includes(modeArg)) {
+        await bot.sendMessage(validatedChatId, 'Usage: /setmode <daily|interval>\n\n• daily - check once per day at configured time\n• interval - check every N hours');
+        return;
+    }
+    const newMode = modeArg;
+    configData.scheduleMode = newMode;
+    saveConfig();
+    // Reschedule
+    scheduleChecks();
+    if (newMode === 'daily') {
+        const time = configData.dailyCheckTime || '06:00';
+        await bot.sendMessage(validatedChatId, `📅 Switched to daily mode. Checking at ${time}\n\nUse /settime to change the time.`);
+    }
+    else {
+        await bot.sendMessage(validatedChatId, `🔄 Switched to interval mode. Checking every ${configData.checkIntervalHours} hours\n\nUse /setinterval to change the interval.`);
+    }
 });
 bot.onText(/\/generate/, async (msg) => {
     if (msg.chat.id.toString() !== validatedChatId)
@@ -321,6 +443,12 @@ bot.onText(/\/mirror(?:\s+(.+))?/, async (msg, match) => {
     }
 });
 // Start scheduled checks
-scheduleChecks(configData.checkIntervalHours);
-console.log(`ReleaseRadar started. Checking every ${configData.checkIntervalHours} hours.`);
+scheduleChecks();
+const mode = configData.scheduleMode || 'interval';
+if (mode === 'daily') {
+    console.log(`ReleaseRadar started. Daily check at ${configData.dailyCheckTime || '06:00'}.`);
+}
+else {
+    console.log(`ReleaseRadar started. Checking every ${configData.checkIntervalHours} hours.`);
+}
 console.log(`Tracking ${configData.tools.length} tools.`);

package/dist/mirror-and-publish.d.ts

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

package/dist/mirror-and-publish.js

@@ -0,0 +1,85 @@
+// src/mirror-and-publish.ts
+// Standalone script to mirror assets and publish CLI
+import { readFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { Storage } from './storage.js';
+import { AssetMirror } from './asset-mirror.js';
+import { CliPublisher } from './cli-publisher.js';
+import { fetchVersion } from './fetchers/index.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PKG_ROOT = join(__dirname, '..');
+// Paths
+const CONFIG_PATH = join(PKG_ROOT, 'config', 'tools.json');
+const DOWNLOADS_PATH = join(PKG_ROOT, 'config', 'downloads.json');
+const HOME_DIR = process.env.HOME || process.env.USERPROFILE || '/tmp';
+const DATA_DIR = process.env.RELEASE_RADAR_DATA_DIR || join(HOME_DIR, '.release-radar');
+// Ensure data directory exists
+if (!existsSync(DATA_DIR)) {
+    mkdirSync(DATA_DIR, { recursive: true });
+}
+// Load configs
+const configData = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+const downloadsConfig = JSON.parse(readFileSync(DOWNLOADS_PATH, 'utf-8'));
+// Initialize components
+const storage = new Storage(join(DATA_DIR, 'versions.json'));
+const assetMirror = new AssetMirror();
+const USER_CLI_DIR = join(DATA_DIR, 'cli');
+const cliPublisher = new CliPublisher(downloadsConfig, USER_CLI_DIR);
+async function main() {
+    console.log('🔍 Checking versions and mirroring assets...\n');
+    const toolsToMirror = configData.tools.filter((tool) => {
+        const downloadConfig = downloadsConfig[tool.name];
+        return downloadConfig &&
+            downloadConfig.type !== 'npm' &&
+            'mirror' in downloadConfig &&
+            downloadConfig.mirror;
+    });
+    console.log(`Found ${toolsToMirror.length} tools configured for mirroring`);
+    for (const tool of toolsToMirror) {
+        try {
+            console.log(`\n📦 ${tool.name}`);
+            // Fetch current version
+            const version = await fetchVersion(tool);
+            console.log(`  Version: ${version}`);
+            // Store version
+            const oldVersion = storage.getVersion(tool.name);
+            if (oldVersion !== version) {
+                storage.setVersion(tool.name, version);
+                console.log(`  Updated from ${oldVersion || 'none'} to ${version}`);
+            }
+            // Mirror asset
+            const downloadConfig = downloadsConfig[tool.name];
+            const result = await assetMirror.mirror(tool.name, version, downloadConfig.mirror, downloadConfig.filename);
+            if (result.success && result.downloadUrl) {
+                storage.setMirrorUrl(tool.name, result.downloadUrl);
+                console.log(`  ✅ Mirrored: ${result.downloadUrl}`);
+            }
+            else {
+                console.log(`  ⚠️ Mirror failed: ${result.error}`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`  ❌ Error: ${message}`);
+        }
+    }
+    // Publish CLI
+    console.log('\n\n📦 Publishing CLI...');
+    const state = storage.load();
+    const mirrorUrls = storage.getAllMirrorUrls();
+    const result = await cliPublisher.publish(state.versions, mirrorUrls);
+    if (result.success) {
+        console.log(`✅ CLI published: v${result.version}`);
+    }
+    else {
+        console.error(`❌ CLI publish failed: ${result.error}`);
+        process.exit(1);
+    }
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/types.d.ts

@@ -8,8 +8,11 @@ export interface ToolConfig {
     fallbackUrl?: string;
     customFetcher?: string;
 }
+export type ScheduleMode = 'interval' | 'daily';
 export interface Config {
     checkIntervalHours: number;
+    scheduleMode?: ScheduleMode;
+    dailyCheckTime?: string;
     tools: ToolConfig[];
 }
 export interface MirrorConfig {

package/package.json

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