@lvnt/release-radar 1.7.15 → 1.8.2

package/config/downloads.json

@@ -1,8 +1,21 @@
 {
+  "VSCode": {
+    "displayName": "VS Code",
+    "downloadUrl": "{{MIRROR_URL}}",
+    "filename": "VSCode-{{VERSION}}-win-x64.msi",
+    "mirror": {
+      "sourceUrl": "https://update.code.visualstudio.com/latest/win32-x64/stable"
+    }
+  },
   "Claude Code VSCode": {
     "displayName": "Claude Code Extension",
     "downloadUrl": "{{MIRROR_URL}}",
-    "filename": "claude-code-{{VERSION}}-win32-x64.vsix"
+    "filename": "claude-code-{{VERSION}}-win32-x64.vsix",
+    "mirror": {
+      "sourceUrl": "marketplace-api",
+      "extensionId": "anthropic.claude-code",
+      "targetPlatform": "win32-x64"
+    }
   },
   "Claude Code CLI": {
     "displayName": "Claude Code CLI",
@@ -78,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

@@ -85,6 +85,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

@@ -0,0 +1,17 @@
+import type { MirrorConfig } from './types.js';
+export interface MirrorResult {
+    success: boolean;
+    downloadUrl?: string;
+    error?: string;
+}
+export declare class AssetMirror {
+    private repo;
+    mirror(toolName: string, version: string, config: MirrorConfig, filenameTemplate: string): Promise<MirrorResult>;
+    buildTag(toolName: string, version: string): string;
+    releaseExists(tag: string): Promise<boolean>;
+    private applyVersion;
+    private getSourceUrl;
+    private getMarketplaceVsixUrl;
+    private downloadFile;
+    private createRelease;
+}

package/dist/asset-mirror.js

@@ -0,0 +1,121 @@
+// src/asset-mirror.ts
+import { execSync } from 'child_process';
+import { unlinkSync, existsSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+export class AssetMirror {
+    repo = 'lvntbkdmr/apps';
+    async mirror(toolName, version, config, filenameTemplate) {
+        const tag = this.buildTag(toolName, version);
+        const filename = this.applyVersion(filenameTemplate, version);
+        const downloadUrl = `github.com/${this.repo}/releases/download/${tag}/${filename}`;
+        try {
+            // Check if release already exists
+            if (await this.releaseExists(tag)) {
+                console.log(`[AssetMirror] Release ${tag} already exists, skipping`);
+                return { success: true, downloadUrl };
+            }
+            // Get actual source URL
+            console.log(`[AssetMirror] Getting source URL for ${toolName} v${version}...`);
+            const sourceUrl = await this.getSourceUrl(config, version);
+            // Download to temp file
+            const tempPath = join(tmpdir(), filename);
+            console.log(`[AssetMirror] Downloading to ${tempPath}...`);
+            await this.downloadFile(sourceUrl, tempPath);
+            // Create GitHub release with asset attached
+            console.log(`[AssetMirror] Creating release ${tag}...`);
+            await this.createRelease(tag, tempPath, filename, toolName, version);
+            // Cleanup temp file
+            if (existsSync(tempPath)) {
+                unlinkSync(tempPath);
+            }
+            console.log(`[AssetMirror] Successfully mirrored to ${downloadUrl}`);
+            return { success: true, downloadUrl };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`[AssetMirror] Failed to mirror ${toolName}: ${message}`);
+            return { success: false, error: message };
+        }
+    }
+    buildTag(toolName, version) {
+        const kebab = toolName.toLowerCase().replace(/\s+/g, '-');
+        return `${kebab}-v${version}`;
+    }
+    async releaseExists(tag) {
+        try {
+            execSync(`gh release view ${tag} --repo ${this.repo}`, {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    applyVersion(template, version) {
+        return template.replace(/\{\{VERSION\}\}/g, version);
+    }
+    async getSourceUrl(config, version) {
+        if (config.sourceUrl === 'marketplace-api') {
+            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(extensionId, version, targetPlatform) {
+        const query = JSON.stringify({
+            filters: [{
+                    criteria: [{ filterType: 7, value: extensionId }],
+                    pageNumber: 1,
+                    pageSize: 1,
+                }],
+            flags: 3,
+        });
+        const cmd = `curl -sS 'https://marketplace.visualstudio.com/_apis/public/gallery/extensionquery' ` +
+            `-H 'Accept: application/json; api-version=7.2-preview.1' ` +
+            `-H 'Content-Type: application/json' ` +
+            `--data '${query}'`;
+        const response = execSync(cmd, { encoding: 'utf-8', timeout: 30000 });
+        const data = JSON.parse(response);
+        const versions = data.results?.[0]?.extensions?.[0]?.versions || [];
+        // 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) {
+            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 for ${extensionId}`);
+        }
+        return vsixFile.source;
+    }
+    async downloadFile(url, destPath) {
+        execSync(`curl -sS -L -o "${destPath}" "${url}"`, {
+            encoding: 'utf-8',
+            timeout: 300000, // 5 minutes for large files
+        });
+        if (!existsSync(destPath)) {
+            throw new Error('Download failed - file not created');
+        }
+    }
+    async createRelease(tag, filePath, filename, toolName, version) {
+        const title = `${toolName} ${version}`;
+        const notes = `Mirrored for Nexus proxy access.`;
+        execSync(`gh release create "${tag}" "${filePath}#${filename}" ` +
+            `--repo ${this.repo} --title "${title}" --notes "${notes}"`, { encoding: 'utf-8', timeout: 300000 });
+    }
+}

package/dist/asset-mirror.test.js

@@ -0,0 +1,159 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { AssetMirror } from './asset-mirror.js';
+import { execSync } from 'child_process';
+import { existsSync, unlinkSync } from 'fs';
+vi.mock('child_process', () => ({
+    execSync: vi.fn()
+}));
+vi.mock('fs', () => ({
+    existsSync: vi.fn(),
+    unlinkSync: vi.fn()
+}));
+describe('AssetMirror', () => {
+    let mirror;
+    beforeEach(() => {
+        vi.resetAllMocks();
+        mirror = new AssetMirror();
+    });
+    describe('buildTag', () => {
+        it('converts tool name to kebab-case tag', () => {
+            expect(mirror.buildTag('VSCode', '1.96.0')).toBe('vscode-v1.96.0');
+            expect(mirror.buildTag('Claude Code VSCode', '2.1.9')).toBe('claude-code-vscode-v2.1.9');
+            expect(mirror.buildTag('Ninja', '1.12.0')).toBe('ninja-v1.12.0');
+        });
+    });
+    describe('mirror', () => {
+        it('returns existing URL if release already exists', async () => {
+            vi.mocked(execSync).mockReturnValueOnce(Buffer.from(''));
+            const result = await mirror.mirror('VSCode', '1.96.0', {
+                sourceUrl: 'https://update.code.visualstudio.com/latest/win32-x64/stable'
+            }, 'VSCode-{{VERSION}}-win-x64.msi');
+            expect(result.success).toBe(true);
+            expect(result.downloadUrl).toBe('github.com/lvntbkdmr/apps/releases/download/vscode-v1.96.0/VSCode-1.96.0-win-x64.msi');
+            expect(execSync).toHaveBeenCalledTimes(1);
+        });
+        it('returns error when download fails', async () => {
+            // gh release view fails = release does not exist
+            vi.mocked(execSync).mockImplementationOnce(() => {
+                throw new Error('release not found');
+            });
+            // curl download fails
+            vi.mocked(execSync).mockImplementationOnce(() => {
+                throw new Error('network error');
+            });
+            const result = await mirror.mirror('VSCode', '1.96.0', {
+                sourceUrl: 'https://update.code.visualstudio.com/latest/win32-x64/stable'
+            }, 'VSCode-{{VERSION}}-win-x64.msi');
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('network error');
+        });
+        it('handles marketplace-api source for Claude Code VSCode', async () => {
+            const marketplaceResponse = JSON.stringify({
+                results: [{
+                        extensions: [{
+                                versions: [{
+                                        version: '2.1.9',
+                                        targetPlatform: 'win32-x64',
+                                        files: [{
+                                                assetType: 'Microsoft.VisualStudio.Services.VSIXPackage',
+                                                source: 'https://marketplace.visualstudio.com/vsix/download'
+                                            }]
+                                    }]
+                            }]
+                    }]
+            });
+            // 1. gh release view fails
+            vi.mocked(execSync).mockImplementationOnce(() => {
+                throw new Error('release not found');
+            });
+            // 2. curl marketplace query succeeds
+            vi.mocked(execSync).mockReturnValueOnce(marketplaceResponse);
+            // 3. curl download succeeds
+            vi.mocked(execSync).mockReturnValueOnce('');
+            // 4. gh release create succeeds
+            vi.mocked(execSync).mockReturnValueOnce('');
+            vi.mocked(existsSync).mockReturnValue(true);
+            const result = await mirror.mirror('Claude Code VSCode', '2.1.9', {
+                sourceUrl: 'marketplace-api',
+                extensionId: 'anthropic.claude-code',
+                targetPlatform: 'win32-x64'
+            }, 'claude-code-{{VERSION}}-win32-x64.vsix');
+            expect(result.success).toBe(true);
+            expect(result.downloadUrl).toBe('github.com/lvntbkdmr/apps/releases/download/claude-code-vscode-v2.1.9/claude-code-2.1.9-win32-x64.vsix');
+        });
+        it('handles universal marketplace extensions without targetPlatform', async () => {
+            const marketplaceResponse = JSON.stringify({
+                results: [{
+                        extensions: [{
+                                versions: [{
+                                        version: '1.2.3',
+                                        files: [{
+                                                assetType: 'Microsoft.VisualStudio.Services.VSIXPackage',
+                                                source: 'https://marketplace.visualstudio.com/vsix/download'
+                                            }]
+                                    }]
+                            }]
+                    }]
+            });
+            // 1. gh release view fails
+            vi.mocked(execSync).mockImplementationOnce(() => {
+                throw new Error('release not found');
+            });
+            // 2. curl marketplace query succeeds
+            vi.mocked(execSync).mockReturnValueOnce(marketplaceResponse);
+            // 3. curl download succeeds
+            vi.mocked(execSync).mockReturnValueOnce('');
+            // 4. gh release create succeeds
+            vi.mocked(execSync).mockReturnValueOnce('');
+            vi.mocked(existsSync).mockReturnValue(true);
+            const result = await mirror.mirror('GitHub Theme', '1.2.3', {
+                sourceUrl: 'marketplace-api',
+                extensionId: 'github.github-vscode-theme'
+            }, 'github-vscode-theme-{{VERSION}}.vsix');
+            expect(result.success).toBe(true);
+            expect(result.downloadUrl).toBe('github.com/lvntbkdmr/apps/releases/download/github-theme-v1.2.3/github-vscode-theme-1.2.3.vsix');
+        });
+        it('fails when extensionId is missing for marketplace-api', async () => {
+            // gh release view fails
+            vi.mocked(execSync).mockImplementationOnce(() => {
+                throw new Error('release not found');
+            });
+            const result = await mirror.mirror('Test Extension', '1.0.0', {
+                sourceUrl: 'marketplace-api'
+            }, 'test-{{VERSION}}.vsix');
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('extensionId is required');
+        });
+        it('successfully mirrors direct URL through full flow', async () => {
+            // 1. gh release view fails
+            vi.mocked(execSync).mockImplementationOnce(() => {
+                throw new Error('release not found');
+            });
+            // 2. curl download succeeds
+            vi.mocked(execSync).mockReturnValueOnce('');
+            // 3. gh release create succeeds
+            vi.mocked(execSync).mockReturnValueOnce('');
+            vi.mocked(existsSync).mockReturnValue(true);
+            const result = await mirror.mirror('VSCode', '1.96.0', {
+                sourceUrl: 'https://update.code.visualstudio.com/latest/win32-x64/stable'
+            }, 'VSCode-{{VERSION}}-win-x64.msi');
+            expect(result.success).toBe(true);
+            expect(execSync).toHaveBeenCalledTimes(3);
+            expect(unlinkSync).toHaveBeenCalled();
+        });
+    });
+    describe('releaseExists', () => {
+        it('returns true when release exists', async () => {
+            vi.mocked(execSync).mockReturnValueOnce(Buffer.from(''));
+            const exists = await mirror.releaseExists('vscode-v1.96.0');
+            expect(exists).toBe(true);
+        });
+        it('returns false when release does not exist', async () => {
+            vi.mocked(execSync).mockImplementationOnce(() => {
+                throw new Error('release not found');
+            });
+            const exists = await mirror.releaseExists('vscode-v1.96.0');
+            expect(exists).toBe(false);
+        });
+    });
+});

package/dist/checker.d.ts

@@ -1,15 +1,17 @@
-import type { ToolConfig } from './types.js';
+import type { ToolConfig, DownloadsConfig } from './types.js';
 import type { Storage } from './storage.js';
 import type { Notifier } from './notifier.js';
-import type { VsixMirror } from './vsix-mirror.js';
+import type { AssetMirror } from './asset-mirror.js';
 export declare class Checker {
     private tools;
     private storage;
     private notifier;
-    private vsixMirror?;
-    constructor(tools: ToolConfig[], storage: Storage, notifier: Notifier, vsixMirror?: VsixMirror | undefined);
+    private assetMirror?;
+    private downloadsConfig?;
+    constructor(tools: ToolConfig[], storage: Storage, notifier: Notifier, assetMirror?: AssetMirror | undefined, downloadsConfig?: DownloadsConfig | undefined);
     checkAll(): Promise<{
         hasUpdates: boolean;
         updateCount: number;
     }>;
+    private mirrorIfConfigured;
 }

package/dist/checker.js

@@ -3,12 +3,14 @@ export class Checker {
     tools;
     storage;
     notifier;
-    vsixMirror;
-    constructor(tools, storage, notifier, vsixMirror) {
+    assetMirror;
+    downloadsConfig;
+    constructor(tools, storage, notifier, assetMirror, downloadsConfig) {
         this.tools = tools;
         this.storage = storage;
         this.notifier = notifier;
-        this.vsixMirror = vsixMirror;
+        this.assetMirror = assetMirror;
+        this.downloadsConfig = downloadsConfig;
     }
     async checkAll() {
         const updates = [];
@@ -24,13 +26,8 @@ export class Checker {
                 else if (oldVersion !== newVersion) {
                     updates.push({ name: tool.name, oldVersion, newVersion });
                     this.storage.setVersion(tool.name, newVersion);
-                    // Mirror VSIX to GitHub if this is Claude Code VSCode
-                    if (tool.name === 'Claude Code VSCode' && this.vsixMirror) {
-                        const mirrorResult = await this.vsixMirror.mirror(newVersion);
-                        if (mirrorResult.success && mirrorResult.downloadUrl) {
-                            this.storage.setMirrorUrl(tool.name, mirrorResult.downloadUrl);
-                        }
-                    }
+                    // Mirror asset if configured
+                    await this.mirrorIfConfigured(tool.name, newVersion);
                 }
             }
             catch (error) {
@@ -42,4 +39,18 @@ export class Checker {
         await this.notifier.sendBatchedFailures(failures);
         return { hasUpdates: updates.length > 0, updateCount: updates.length };
     }
+    async mirrorIfConfigured(toolName, version) {
+        if (!this.assetMirror || !this.downloadsConfig)
+            return;
+        const downloadConfig = this.downloadsConfig[toolName];
+        if (!downloadConfig || downloadConfig.type === 'npm')
+            return;
+        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);
+        }
+    }
 }

package/dist/checker.test.js

@@ -78,52 +78,61 @@ describe('Checker', () => {
         expect(result.hasUpdates).toBe(false);
         expect(result.updateCount).toBe(0);
     });
-    describe('VSIX mirroring', () => {
-        let mockVsixMirror;
+    describe('Asset mirroring', () => {
+        let mockAssetMirror;
+        let downloadsConfig;
         beforeEach(() => {
-            mockVsixMirror = {
-                mirror: vi.fn().mockResolvedValue({ success: true, downloadUrl: 'github.com/test/url.vsix' })
+            mockAssetMirror = {
+                mirror: vi.fn().mockResolvedValue({ success: true, downloadUrl: 'github.com/test/url' })
             };
-        });
-        it('mirrors VSIX when Claude Code VSCode updates', async () => {
-            const vsCodeTool = {
-                name: 'Claude Code VSCode',
-                type: 'vscode-marketplace',
-                extensionId: 'anthropic.claude-code'
+            downloadsConfig = {
+                'VSCode': {
+                    displayName: 'VS Code',
+                    downloadUrl: '{{MIRROR_URL}}',
+                    filename: 'VSCode-{{VERSION}}-win-x64.msi',
+                    mirror: { sourceUrl: 'https://update.code.visualstudio.com/latest/win32-x64/stable' }
+                },
+                'Ninja': {
+                    displayName: 'Ninja',
+                    downloadUrl: 'github.com/ninja/releases/{{VERSION}}/ninja.zip',
+                    filename: 'ninja-{{VERSION}}.zip'
+                    // No mirror config
+                }
             };
-            const checkerWithMirror = new Checker([vsCodeTool], mockStorage, mockNotifier, mockVsixMirror);
-            mockStorage.getVersion.mockReturnValue('2.1.8');
-            vi.mocked(fetchVersion).mockResolvedValue('2.1.9');
+        });
+        it('mirrors asset when tool has mirror config and version updates', async () => {
+            const vscodeTool = { name: 'VSCode', type: 'custom', customFetcher: 'vscode' };
+            const checkerWithMirror = new Checker([vscodeTool], mockStorage, mockNotifier, mockAssetMirror, downloadsConfig);
+            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(mockStorage.setMirrorUrl).toHaveBeenCalledWith('VSCode', 'github.com/test/url');
+        });
+        it('does not mirror when tool has no mirror config', async () => {
+            const ninjaTool = { name: 'Ninja', type: 'github', repo: 'ninja-build/ninja' };
+            const checkerWithMirror = new Checker([ninjaTool], mockStorage, mockNotifier, mockAssetMirror, downloadsConfig);
+            mockStorage.getVersion.mockReturnValue('1.11.0');
+            vi.mocked(fetchVersion).mockResolvedValue('1.12.0');
             await checkerWithMirror.checkAll();
-            expect(mockVsixMirror.mirror).toHaveBeenCalledWith('2.1.9');
-            expect(mockStorage.setMirrorUrl).toHaveBeenCalledWith('Claude Code VSCode', 'github.com/test/url.vsix');
+            expect(mockAssetMirror.mirror).not.toHaveBeenCalled();
         });
         it('does not mirror when version unchanged', async () => {
-            const vsCodeTool = {
-                name: 'Claude Code VSCode',
-                type: 'vscode-marketplace',
-                extensionId: 'anthropic.claude-code'
-            };
-            const checkerWithMirror = new Checker([vsCodeTool], mockStorage, mockNotifier, mockVsixMirror);
-            mockStorage.getVersion.mockReturnValue('2.1.9');
-            vi.mocked(fetchVersion).mockResolvedValue('2.1.9');
+            const vscodeTool = { name: 'VSCode', type: 'custom', customFetcher: 'vscode' };
+            const checkerWithMirror = new Checker([vscodeTool], mockStorage, mockNotifier, mockAssetMirror, downloadsConfig);
+            mockStorage.getVersion.mockReturnValue('1.96.0');
+            vi.mocked(fetchVersion).mockResolvedValue('1.96.0');
             await checkerWithMirror.checkAll();
-            expect(mockVsixMirror.mirror).not.toHaveBeenCalled();
+            expect(mockAssetMirror.mirror).not.toHaveBeenCalled();
         });
         it('continues if mirror fails', async () => {
-            const vsCodeTool = {
-                name: 'Claude Code VSCode',
-                type: 'vscode-marketplace',
-                extensionId: 'anthropic.claude-code'
-            };
-            mockVsixMirror.mirror.mockResolvedValue({ success: false, error: 'network error' });
-            const checkerWithMirror = new Checker([vsCodeTool], mockStorage, mockNotifier, mockVsixMirror);
-            mockStorage.getVersion.mockReturnValue('2.1.8');
-            vi.mocked(fetchVersion).mockResolvedValue('2.1.9');
+            const vscodeTool = { name: 'VSCode', type: 'custom', customFetcher: 'vscode' };
+            mockAssetMirror.mirror.mockResolvedValue({ 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');
             await checkerWithMirror.checkAll();
-            // Version should still be updated
-            expect(mockStorage.setVersion).toHaveBeenCalledWith('Claude Code VSCode', '2.1.9');
-            // But no mirror URL stored
+            expect(mockStorage.setVersion).toHaveBeenCalledWith('VSCode', '1.96.0');
             expect(mockStorage.setMirrorUrl).not.toHaveBeenCalled();
         });
     });

package/dist/index.js

@@ -11,7 +11,7 @@ import { Notifier } from './notifier.js';
 import { Checker } from './checker.js';
 import { generateVersionsJson } from './versions-generator.js';
 import { CliPublisher } from './cli-publisher.js';
-import { VsixMirror } from './vsix-mirror.js';
+import { AssetMirror } from './asset-mirror.js';
 // Get package directory for resolving config paths
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -102,8 +102,8 @@ const bot = new TelegramBot(BOT_TOKEN, { polling: true });
 const storage = new Storage(join(DATA_DIR, 'versions.json'));
 const notifier = new Notifier(bot, validatedChatId);
 const cliPublisher = new CliPublisher(downloadsConfig, USER_CLI_DIR);
-const vsixMirror = new VsixMirror();
-const checker = new Checker(configData.tools, storage, notifier, vsixMirror);
+const assetMirror = new AssetMirror();
+const checker = new Checker(configData.tools, storage, notifier, assetMirror, downloadsConfig);
 // Track scheduled task for rescheduling
 let scheduledTask = null;
 let lastCheckTime = null;
@@ -275,19 +275,45 @@ bot.onText(/\/publishcli/, async (msg) => {
         await bot.sendMessage(validatedChatId, `❌ CLI publish failed: ${result.error}`);
     }
 });
-bot.onText(/\/mirrorvsix(?:\s+(.+))?/, async (msg, match) => {
+bot.onText(/\/mirror(?:\s+(.+))?/, async (msg, match) => {
     if (msg.chat.id.toString() !== validatedChatId)
         return;
-    const versionArg = match?.[1]?.trim();
-    const version = versionArg || storage.getVersion('Claude Code VSCode');
+    const args = match?.[1]?.trim();
+    if (!args) {
+        await bot.sendMessage(validatedChatId, 'Usage: /mirror <toolname> [version]\nExample: /mirror VSCode\nExample: /mirror "Claude Code VSCode" 2.1.9');
+        return;
+    }
+    // Parse tool name and optional version
+    let toolName;
+    let version;
+    const quoteMatch = args.match(/^"([^"]+)"(?:\s+(.+))?$/);
+    if (quoteMatch) {
+        toolName = quoteMatch[1];
+        version = quoteMatch[2]?.trim() || null;
+    }
+    else {
+        const parts = args.split(/\s+/);
+        toolName = parts[0];
+        version = parts[1] || null;
+    }
+    // Get download config for this tool
+    const downloadConfig = downloadsConfig[toolName];
+    if (!downloadConfig || downloadConfig.type === 'npm' || !('mirror' in downloadConfig) || !downloadConfig.mirror) {
+        await bot.sendMessage(validatedChatId, `Tool "${toolName}" is not configured for mirroring.`);
+        return;
+    }
+    // Get version if not provided
+    if (!version) {
+        version = storage.getVersion(toolName);
+    }
     if (!version) {
-        await bot.sendMessage(validatedChatId, 'No version specified and no tracked version found. Usage: /mirrorvsix [version]');
+        await bot.sendMessage(validatedChatId, `No version specified and no tracked version found for "${toolName}".`);
         return;
     }
-    await bot.sendMessage(validatedChatId, `Mirroring Claude Code VSCode v${version}...`);
-    const result = await vsixMirror.mirror(version);
+    await bot.sendMessage(validatedChatId, `Mirroring ${toolName} v${version}...`);
+    const result = await assetMirror.mirror(toolName, version, downloadConfig.mirror, downloadConfig.filename);
     if (result.success) {
-        storage.setMirrorUrl('Claude Code VSCode', result.downloadUrl);
+        storage.setMirrorUrl(toolName, result.downloadUrl);
         await bot.sendMessage(validatedChatId, `✅ Mirrored successfully\nURL: ${result.downloadUrl}`);
     }
     else {

package/dist/types.d.ts

@@ -12,11 +12,17 @@ export interface Config {
     checkIntervalHours: number;
     tools: ToolConfig[];
 }
+export interface MirrorConfig {
+    sourceUrl: string;
+    extensionId?: string;
+    targetPlatform?: string;
+}
 export interface DownloadConfigUrl {
     type?: 'download';
     displayName: string;
     downloadUrl: string;
     filename: string;
+    mirror?: MirrorConfig;
 }
 export interface DownloadConfigNpm {
     type: 'npm';

package/package.json

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

package/dist/vsix-mirror.d.ts

@@ -1,15 +0,0 @@
-export interface MirrorResult {
-    success: boolean;
-    downloadUrl?: string;
-    error?: string;
-}
-export declare class VsixMirror {
-    private repo;
-    private extensionId;
-    private targetPlatform;
-    mirror(version: string): Promise<MirrorResult>;
-    releaseExists(tag: string): Promise<boolean>;
-    private getMarketplaceVsixUrl;
-    private downloadVsix;
-    private createRelease;
-}

package/dist/vsix-mirror.js

@@ -1,96 +0,0 @@
-// src/vsix-mirror.ts
-import { execSync } from 'child_process';
-import { unlinkSync, existsSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-export class VsixMirror {
-    repo = 'lvntbkdmr/apps';
-    extensionId = 'anthropic.claude-code';
-    targetPlatform = 'win32-x64';
-    async mirror(version) {
-        const tag = `claude-code-vsix-v${version}`;
-        const filename = `claude-code-${version}-win32-x64.vsix`;
-        const downloadUrl = `github.com/${this.repo}/releases/download/${tag}/${filename}`;
-        try {
-            // Check if release already exists
-            if (await this.releaseExists(tag)) {
-                console.log(`[VsixMirror] Release ${tag} already exists, skipping`);
-                return { success: true, downloadUrl };
-            }
-            // Get VSIX URL from marketplace
-            console.log(`[VsixMirror] Querying marketplace for ${this.extensionId} v${version}...`);
-            const vsixUrl = await this.getMarketplaceVsixUrl(version);
-            // Download VSIX to temp file
-            const tempPath = join(tmpdir(), filename);
-            console.log(`[VsixMirror] Downloading VSIX to ${tempPath}...`);
-            await this.downloadVsix(vsixUrl, tempPath);
-            // Create GitHub release with VSIX attached
-            console.log(`[VsixMirror] Creating release ${tag}...`);
-            await this.createRelease(tag, tempPath, filename, version);
-            // Cleanup temp file
-            if (existsSync(tempPath)) {
-                unlinkSync(tempPath);
-            }
-            console.log(`[VsixMirror] Successfully mirrored to ${downloadUrl}`);
-            return { success: true, downloadUrl };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.error(`[VsixMirror] Failed to mirror: ${message}`);
-            return { success: false, error: message };
-        }
-    }
-    async releaseExists(tag) {
-        try {
-            execSync(`gh release view ${tag} --repo ${this.repo}`, {
-                encoding: 'utf-8',
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async getMarketplaceVsixUrl(version) {
-        const query = JSON.stringify({
-            filters: [{
-                    criteria: [{ filterType: 7, value: this.extensionId }],
-                    pageNumber: 1,
-                    pageSize: 1,
-                }],
-            flags: 3,
-        });
-        const cmd = `curl -sS 'https://marketplace.visualstudio.com/_apis/public/gallery/extensionquery' ` +
-            `-H 'Accept: application/json; api-version=7.2-preview.1' ` +
-            `-H 'Content-Type: application/json' ` +
-            `--data '${query}'`;
-        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 === this.targetPlatform);
-        if (!targetVersion) {
-            throw new Error(`Version ${version} for ${this.targetPlatform} not found in marketplace`);
-        }
-        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');
-        }
-        return vsixFile.source;
-    }
-    async downloadVsix(url, destPath) {
-        execSync(`curl -sS -L -o "${destPath}" "${url}"`, {
-            encoding: 'utf-8',
-            timeout: 300000, // 5 minutes for large files
-        });
-        if (!existsSync(destPath)) {
-            throw new Error('Download failed - file not created');
-        }
-    }
-    async createRelease(tag, vsixPath, filename, version) {
-        const title = `Claude Code VSCode ${version}`;
-        const notes = `Mirrored from VS Code Marketplace for Nexus proxy access.\n\nPlatform: win32-x64`;
-        execSync(`gh release create "${tag}" "${vsixPath}#${filename}" ` +
-            `--repo ${this.repo} --title "${title}" --notes "${notes}"`, { encoding: 'utf-8', timeout: 300000 });
-    }
-}

package/dist/vsix-mirror.test.js

@@ -1,96 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { VsixMirror } from './vsix-mirror.js';
-import { execSync } from 'child_process';
-import { existsSync, unlinkSync } from 'fs';
-vi.mock('child_process', () => ({
-    execSync: vi.fn()
-}));
-vi.mock('fs', () => ({
-    existsSync: vi.fn(),
-    unlinkSync: vi.fn()
-}));
-describe('VsixMirror', () => {
-    let mirror;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mirror = new VsixMirror();
-    });
-    describe('mirror', () => {
-        it('returns existing URL if release already exists', async () => {
-            // gh release view succeeds = release exists
-            vi.mocked(execSync).mockReturnValueOnce(Buffer.from(''));
-            const result = await mirror.mirror('2.1.9');
-            expect(result.success).toBe(true);
-            expect(result.downloadUrl).toBe('github.com/lvntbkdmr/apps/releases/download/claude-code-vsix-v2.1.9/claude-code-2.1.9-win32-x64.vsix');
-            // Should not attempt to create release
-            expect(execSync).toHaveBeenCalledTimes(1);
-        });
-        it('returns error when marketplace query fails', async () => {
-            // gh release view fails = release does not exist
-            vi.mocked(execSync).mockImplementationOnce(() => {
-                throw new Error('release not found');
-            });
-            // curl for marketplace query fails
-            vi.mocked(execSync).mockImplementationOnce(() => {
-                throw new Error('network error');
-            });
-            const result = await mirror.mirror('2.1.9');
-            expect(result.success).toBe(false);
-            expect(result.error).toContain('network error');
-        });
-        it('successfully mirrors new version through full flow', async () => {
-            const marketplaceResponse = JSON.stringify({
-                results: [{
-                        extensions: [{
-                                versions: [{
-                                        version: '2.1.9',
-                                        targetPlatform: 'win32-x64',
-                                        files: [{
-                                                assetType: 'Microsoft.VisualStudio.Services.VSIXPackage',
-                                                source: 'https://marketplace.visualstudio.com/vsix/download'
-                                            }]
-                                    }]
-                            }]
-                    }]
-            });
-            // 1. gh release view fails = release does not exist
-            vi.mocked(execSync).mockImplementationOnce(() => {
-                throw new Error('release not found');
-            });
-            // 2. curl marketplace query succeeds
-            vi.mocked(execSync).mockReturnValueOnce(marketplaceResponse);
-            // 3. curl download succeeds (returns empty)
-            vi.mocked(execSync).mockReturnValueOnce('');
-            // 4. gh release create succeeds
-            vi.mocked(execSync).mockReturnValueOnce('');
-            // Mock existsSync to return true (file exists after download)
-            vi.mocked(existsSync).mockReturnValue(true);
-            const result = await mirror.mirror('2.1.9');
-            expect(result.success).toBe(true);
-            expect(result.downloadUrl).toBe('github.com/lvntbkdmr/apps/releases/download/claude-code-vsix-v2.1.9/claude-code-2.1.9-win32-x64.vsix');
-            expect(execSync).toHaveBeenCalledTimes(4);
-            // Verify the gh release create was called with correct arguments
-            const lastCall = vi.mocked(execSync).mock.calls[3][0];
-            expect(lastCall).toContain('gh release create');
-            expect(lastCall).toContain('claude-code-vsix-v2.1.9');
-            expect(lastCall).toContain('--repo lvntbkdmr/apps');
-            // Verify cleanup was called
-            expect(unlinkSync).toHaveBeenCalled();
-        });
-    });
-    describe('releaseExists', () => {
-        it('returns true when release exists', async () => {
-            vi.mocked(execSync).mockReturnValueOnce(Buffer.from(''));
-            const exists = await mirror.releaseExists('claude-code-vsix-v2.1.9');
-            expect(exists).toBe(true);
-            expect(execSync).toHaveBeenCalledWith('gh release view claude-code-vsix-v2.1.9 --repo lvntbkdmr/apps', expect.any(Object));
-        });
-        it('returns false when release does not exist', async () => {
-            vi.mocked(execSync).mockImplementationOnce(() => {
-                throw new Error('release not found');
-            });
-            const exists = await mirror.releaseExists('claude-code-vsix-v2.1.9');
-            expect(exists).toBe(false);
-        });
-    });
-});