@lvnt/release-radar 1.7.16 → 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/downloads.json

@@ -12,7 +12,9 @@
     "downloadUrl": "{{MIRROR_URL}}",
     "filename": "claude-code-{{VERSION}}-win32-x64.vsix",
     "mirror": {
-      "sourceUrl": "marketplace-api"
+      "sourceUrl": "marketplace-api",
+      "extensionId": "anthropic.claude-code",
+      "targetPlatform": "win32-x64"
     }
   },
   "Claude Code CLI": {
@@ -89,5 +91,104 @@
     "displayName": "PowerShell",
     "downloadUrl": "github.com/PowerShell/PowerShell/releases/download/v{{VERSION}}/PowerShell-{{VERSION}}-win-x64.msi",
     "filename": "PowerShell-{{VERSION}}-win-x64.msi"
+  },
+  "C/C++ Extension Pack": {
+    "displayName": "C/C++ Extension Pack",
+    "downloadUrl": "{{MIRROR_URL}}",
+    "filename": "cpptools-extension-pack-{{VERSION}}.vsix",
+    "mirror": {
+      "sourceUrl": "marketplace-api",
+      "extensionId": "ms-vscode.cpptools-extension-pack"
+    }
+  },
+  "C/C++ Themes": {
+    "displayName": "C/C++ Themes",
+    "downloadUrl": "{{MIRROR_URL}}",
+    "filename": "cpptools-themes-{{VERSION}}.vsix",
+    "mirror": {
+      "sourceUrl": "marketplace-api",
+      "extensionId": "ms-vscode.cpptools-themes"
+    }
+  },
+  "YAML": {
+    "displayName": "YAML Extension",
+    "downloadUrl": "{{MIRROR_URL}}",
+    "filename": "vscode-yaml-{{VERSION}}.vsix",
+    "mirror": {
+      "sourceUrl": "marketplace-api",
+      "extensionId": "redhat.vscode-yaml"
+    }
+  },
+  "Python": {
+    "displayName": "Python Extension",
+    "downloadUrl": "{{MIRROR_URL}}",
+    "filename": "python-{{VERSION}}.vsix",
+    "mirror": {
+      "sourceUrl": "marketplace-api",
+      "extensionId": "ms-python.python"
+    }
+  },
+  "Python Debugger": {
+    "displayName": "Python Debugger",
+    "downloadUrl": "{{MIRROR_URL}}",
+    "filename": "debugpy-{{VERSION}}.vsix",
+    "mirror": {
+      "sourceUrl": "marketplace-api",
+      "extensionId": "ms-python.debugpy"
+    }
+  },
+  "Python Environments": {
+    "displayName": "Python Environments",
+    "downloadUrl": "{{MIRROR_URL}}",
+    "filename": "vscode-python-envs-{{VERSION}}.vsix",
+    "mirror": {
+      "sourceUrl": "marketplace-api",
+      "extensionId": "ms-python.vscode-python-envs"
+    }
+  },
+  "Pylance": {
+    "displayName": "Pylance",
+    "downloadUrl": "{{MIRROR_URL}}",
+    "filename": "vscode-pylance-{{VERSION}}.vsix",
+    "mirror": {
+      "sourceUrl": "marketplace-api",
+      "extensionId": "ms-python.vscode-pylance"
+    }
+  },
+  "isort": {
+    "displayName": "isort Extension",
+    "downloadUrl": "{{MIRROR_URL}}",
+    "filename": "isort-{{VERSION}}.vsix",
+    "mirror": {
+      "sourceUrl": "marketplace-api",
+      "extensionId": "ms-python.isort"
+    }
+  },
+  "Go": {
+    "displayName": "Go Extension",
+    "downloadUrl": "{{MIRROR_URL}}",
+    "filename": "go-{{VERSION}}.vsix",
+    "mirror": {
+      "sourceUrl": "marketplace-api",
+      "extensionId": "golang.go"
+    }
+  },
+  "GitHub Theme": {
+    "displayName": "GitHub Theme",
+    "downloadUrl": "{{MIRROR_URL}}",
+    "filename": "github-vscode-theme-{{VERSION}}.vsix",
+    "mirror": {
+      "sourceUrl": "marketplace-api",
+      "extensionId": "github.github-vscode-theme"
+    }
+  },
+  "Material Icon Theme": {
+    "displayName": "Material Icon Theme",
+    "downloadUrl": "{{MIRROR_URL}}",
+    "filename": "material-icon-theme-{{VERSION}}.vsix",
+    "mirror": {
+      "sourceUrl": "marketplace-api",
+      "extensionId": "pkief.material-icon-theme"
+    }
   }
 }

package/config/tools.json

@@ -1,5 +1,7 @@
 {
-  "checkIntervalHours": 1,
+  "checkIntervalHours": 6,
+  "scheduleMode": "daily",
+  "dailyCheckTime": "06:00",
   "tools": [
     {
       "name": "VSCode",
@@ -85,6 +87,61 @@
       "name": "PowerShell",
       "type": "github",
       "repo": "PowerShell/PowerShell"
+    },
+    {
+      "name": "C/C++ Extension Pack",
+      "type": "vscode-marketplace",
+      "extensionId": "ms-vscode.cpptools-extension-pack"
+    },
+    {
+      "name": "C/C++ Themes",
+      "type": "vscode-marketplace",
+      "extensionId": "ms-vscode.cpptools-themes"
+    },
+    {
+      "name": "YAML",
+      "type": "vscode-marketplace",
+      "extensionId": "redhat.vscode-yaml"
+    },
+    {
+      "name": "Python",
+      "type": "vscode-marketplace",
+      "extensionId": "ms-python.python"
+    },
+    {
+      "name": "Python Debugger",
+      "type": "vscode-marketplace",
+      "extensionId": "ms-python.debugpy"
+    },
+    {
+      "name": "Python Environments",
+      "type": "vscode-marketplace",
+      "extensionId": "ms-python.vscode-python-envs"
+    },
+    {
+      "name": "Pylance",
+      "type": "vscode-marketplace",
+      "extensionId": "ms-python.vscode-pylance"
+    },
+    {
+      "name": "isort",
+      "type": "vscode-marketplace",
+      "extensionId": "ms-python.isort"
+    },
+    {
+      "name": "Go",
+      "type": "vscode-marketplace",
+      "extensionId": "golang.go"
+    },
+    {
+      "name": "GitHub Theme",
+      "type": "vscode-marketplace",
+      "extensionId": "github.github-vscode-theme"
+    },
+    {
+      "name": "Material Icon Theme",
+      "type": "vscode-marketplace",
+      "extensionId": "pkief.material-icon-theme"
     }
   ]
 }

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}`, {
@@ -59,14 +138,15 @@ export class AssetMirror {
     }
     async getSourceUrl(config, version) {
         if (config.sourceUrl === 'marketplace-api') {
-            return this.getMarketplaceVsixUrl(version);
+            if (!config.extensionId) {
+                throw new Error('extensionId is required when sourceUrl is "marketplace-api"');
+            }
+            return this.getMarketplaceVsixUrl(config.extensionId, version, config.targetPlatform);
         }
         // For direct URLs, just return as-is (curl -L will follow redirects)
         return config.sourceUrl;
     }
-    async getMarketplaceVsixUrl(version) {
-        const extensionId = 'anthropic.claude-code';
-        const targetPlatform = 'win32-x64';
+    async getMarketplaceVsixUrl(extensionId, version, targetPlatform) {
         const query = JSON.stringify({
             filters: [{
                     criteria: [{ filterType: 7, value: extensionId }],
@@ -82,13 +162,23 @@ export class AssetMirror {
         const response = execSync(cmd, { encoding: 'utf-8', timeout: 30000 });
         const data = JSON.parse(response);
         const versions = data.results?.[0]?.extensions?.[0]?.versions || [];
-        const targetVersion = versions.find((v) => v.version === version && v.targetPlatform === targetPlatform);
+        // Find matching version - with or without platform filter
+        const targetVersion = versions.find((v) => {
+            if (v.version !== version)
+                return false;
+            if (targetPlatform) {
+                return v.targetPlatform === targetPlatform;
+            }
+            // For universal extensions, targetPlatform is undefined/null
+            return !v.targetPlatform;
+        });
         if (!targetVersion) {
-            throw new Error(`Version ${version} for ${targetPlatform} not found in marketplace`);
+            const platformInfo = targetPlatform ? ` for ${targetPlatform}` : ' (universal)';
+            throw new Error(`Version ${version}${platformInfo} not found in marketplace for ${extensionId}`);
         }
         const vsixFile = targetVersion.files?.find((f) => f.assetType === 'Microsoft.VisualStudio.Services.VSIXPackage');
         if (!vsixFile?.source) {
-            throw new Error('VSIX download URL not found in marketplace response');
+            throw new Error(`VSIX download URL not found in marketplace response for ${extensionId}`);
         }
         return vsixFile.source;
     }
@@ -107,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
+        );
+    }
 }