@lvnt/release-radar 1.9.0 → 1.9.2

package/cli/src/index.ts

@@ -7,7 +7,7 @@ import { DownloadTracker } from './tracker.js';
 import { loadVersions } from './versions.js';
 import { checkAndUpdate } from './updater.js';
 import { downloadFile, updateNpmPackage } from './downloader.js';
-import { promptSetup, promptToolSelection, renderTable, type ToolChoice, type TableRow } from './ui.js';
+import { promptSetup, promptToolSelection, renderTable, isVscodeExtension, type ToolChoice, type TableRow } from './ui.js';
 import { isNpmTool } from './types.js';
 
 function getVersion(): string {
@@ -89,6 +89,7 @@ async function showStatus(): Promise<void> {
       downloadedVersion: record?.version ?? '-',
       status,
       type: isNpmTool(tool) ? 'npm' : 'download',
+      category: isVscodeExtension(tool) ? 'vscode-extension' : 'tool',
     };
   });
 

package/cli/src/ui.ts

@@ -226,7 +226,7 @@ export function renderTable(rows: TableRow[]): void {
   }
 }
 
-function isVscodeExtension(tool: VersionsJsonTool): boolean {
+export function isVscodeExtension(tool: VersionsJsonTool): boolean {
   if (isNpmTool(tool)) return false;
   // Check if filename ends with .vsix
   return tool.filename.toLowerCase().endsWith('.vsix');

package/dist/index.js

@@ -397,6 +397,58 @@ bot.onText(/\/publishcli/, async (msg) => {
         await bot.sendMessage(validatedChatId, `❌ CLI publish failed: ${result.error}`);
     }
 });
+bot.onText(/\/mirrorall/, async (msg) => {
+    if (msg.chat.id.toString() !== validatedChatId)
+        return;
+    // Find all tools that need mirroring (have mirror config and use {{MIRROR_URL}})
+    const mirrorItems = [];
+    for (const [toolName, config] of Object.entries(downloadsConfig)) {
+        if (config.type === 'npm' || !('mirror' in config) || !config.mirror)
+            continue;
+        if (config.downloadUrl !== '{{MIRROR_URL}}')
+            continue;
+        const version = storage.getVersion(toolName);
+        if (!version) {
+            console.log(`[mirrorall] Skipping ${toolName}: no tracked version`);
+            continue;
+        }
+        mirrorItems.push({
+            toolName,
+            version,
+            config: config.mirror,
+            filenameTemplate: config.filename,
+        });
+    }
+    if (mirrorItems.length === 0) {
+        await bot.sendMessage(validatedChatId, 'No tools configured for mirroring (or no tracked versions).');
+        return;
+    }
+    const toolList = mirrorItems.map(i => `• ${i.toolName} v${i.version}`).join('\n');
+    await bot.sendMessage(validatedChatId, `🔄 Mirroring ${mirrorItems.length} tools...\n\n${toolList}`);
+    const result = await assetMirror.mirrorBatch(mirrorItems);
+    // Update storage with successful mirrors
+    let successCount = 0;
+    let failCount = 0;
+    const failures = [];
+    for (const [toolName, mirrorResult] of result.results) {
+        if (mirrorResult.success && mirrorResult.downloadUrl) {
+            storage.setMirrorUrl(toolName, mirrorResult.downloadUrl);
+            successCount++;
+        }
+        else {
+            failCount++;
+            failures.push(`• ${toolName}: ${mirrorResult.error || 'Unknown error'}`);
+        }
+    }
+    let message = `✅ Mirrored ${successCount}/${mirrorItems.length} tools`;
+    if (result.tag) {
+        message += `\nRelease: ${result.tag}`;
+    }
+    if (failCount > 0) {
+        message += `\n\n❌ ${failCount} failed:\n${failures.join('\n')}`;
+    }
+    await bot.sendMessage(validatedChatId, message);
+});
 bot.onText(/\/mirror(?:\s+(.+))?/, async (msg, match) => {
     if (msg.chat.id.toString() !== validatedChatId)
         return;

package/dist/vsix-mirror.d.ts

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,96 @@
+// 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.d.ts

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

package/dist/vsix-mirror.test.js

@@ -0,0 +1,96 @@
+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);
+        });
+    });
+});

package/package.json

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