@lvnt/release-radar 1.7.13 → 1.7.14

package/config/downloads.json

@@ -1,4 +1,9 @@
 {
+  "Claude Code VSCode": {
+    "displayName": "Claude Code Extension",
+    "downloadUrl": "{{MIRROR_URL}}",
+    "filename": "claude-code-{{VERSION}}-win32-x64.vsix"
+  },
   "Claude Code CLI": {
     "displayName": "Claude Code CLI",
     "downloadUrl": "storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases/{{VERSION}}/win32-x64/claude.exe",

package/dist/checker.d.ts

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

package/dist/checker.js

@@ -3,10 +3,12 @@ export class Checker {
     tools;
     storage;
     notifier;
-    constructor(tools, storage, notifier) {
+    vsixMirror;
+    constructor(tools, storage, notifier, vsixMirror) {
         this.tools = tools;
         this.storage = storage;
         this.notifier = notifier;
+        this.vsixMirror = vsixMirror;
     }
     async checkAll() {
         const updates = [];
@@ -22,6 +24,13 @@ 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);
+                        }
+                    }
                 }
             }
             catch (error) {

package/dist/checker.test.js

@@ -14,7 +14,8 @@ describe('Checker', () => {
         vi.clearAllMocks();
         mockStorage = {
             getVersion: vi.fn(),
-            setVersion: vi.fn()
+            setVersion: vi.fn(),
+            setMirrorUrl: vi.fn()
         };
         mockNotifier = {
             sendBatchedUpdates: vi.fn().mockResolvedValue(undefined),
@@ -77,4 +78,53 @@ describe('Checker', () => {
         expect(result.hasUpdates).toBe(false);
         expect(result.updateCount).toBe(0);
     });
+    describe('VSIX mirroring', () => {
+        let mockVsixMirror;
+        beforeEach(() => {
+            mockVsixMirror = {
+                mirror: vi.fn().mockResolvedValue({ success: true, downloadUrl: 'github.com/test/url.vsix' })
+            };
+        });
+        it('mirrors VSIX when Claude Code VSCode updates', 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.8');
+            vi.mocked(fetchVersion).mockResolvedValue('2.1.9');
+            await checkerWithMirror.checkAll();
+            expect(mockVsixMirror.mirror).toHaveBeenCalledWith('2.1.9');
+            expect(mockStorage.setMirrorUrl).toHaveBeenCalledWith('Claude Code VSCode', 'github.com/test/url.vsix');
+        });
+        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');
+            await checkerWithMirror.checkAll();
+            expect(mockVsixMirror.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');
+            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.setMirrorUrl).not.toHaveBeenCalled();
+        });
+    });
 });

package/dist/cli-publisher.d.ts

@@ -9,5 +9,5 @@ export declare class CliPublisher {
     private cliPath;
     constructor(downloadsConfig: DownloadsConfig, cliPath?: string);
     isConfigured(): boolean;
-    publish(versions: Record<string, string>): Promise<PublishResult>;
+    publish(versions: Record<string, string>, mirrorUrls?: Record<string, string>): Promise<PublishResult>;
 }

package/dist/cli-publisher.js

@@ -30,13 +30,13 @@ export class CliPublisher {
     isConfigured() {
         return Object.keys(this.downloadsConfig).length > 0 && existsSync(this.cliPath);
     }
-    async publish(versions) {
+    async publish(versions, mirrorUrls = {}) {
         if (!this.isConfigured()) {
             return { success: false, error: 'CLI publisher not configured' };
         }
         try {
-            // Generate versions.json
-            const versionsJson = generateVersionsJson(versions, this.downloadsConfig);
+            // Generate versions.json with mirror URLs
+            const versionsJson = generateVersionsJson(versions, this.downloadsConfig, mirrorUrls);
             // Write to CLI package
             const cliVersionsPath = `${this.cliPath}/versions.json`;
             writeFileSync(cliVersionsPath, JSON.stringify(versionsJson, null, 2));

package/dist/index.js

@@ -11,6 +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';
 // Get package directory for resolving config paths
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -100,8 +101,9 @@ else {
 const bot = new TelegramBot(BOT_TOKEN, { polling: true });
 const storage = new Storage(join(DATA_DIR, 'versions.json'));
 const notifier = new Notifier(bot, validatedChatId);
-const checker = new Checker(configData.tools, storage, notifier);
 const cliPublisher = new CliPublisher(downloadsConfig, USER_CLI_DIR);
+const vsixMirror = new VsixMirror();
+const checker = new Checker(configData.tools, storage, notifier, vsixMirror);
 // Track scheduled task for rescheduling
 let scheduledTask = null;
 let lastCheckTime = null;
@@ -130,7 +132,8 @@ function scheduleChecks(intervalHours) {
         // Auto-publish CLI if updates were detected
         if (result.hasUpdates && cliPublisher.isConfigured()) {
             const state = storage.load();
-            const publishResult = await cliPublisher.publish(state.versions);
+            const mirrorUrls = storage.getAllMirrorUrls();
+            const publishResult = await cliPublisher.publish(state.versions, mirrorUrls);
             if (publishResult.success) {
                 await bot.sendMessage(validatedChatId, `📦 CLI published: v${publishResult.version}`);
             }
@@ -149,7 +152,8 @@ bot.onText(/\/check/, async (msg) => {
     // Auto-publish CLI if updates were detected
     if (result.hasUpdates && cliPublisher.isConfigured()) {
         const state = storage.load();
-        const publishResult = await cliPublisher.publish(state.versions);
+        const mirrorUrls = storage.getAllMirrorUrls();
+        const publishResult = await cliPublisher.publish(state.versions, mirrorUrls);
         if (publishResult.success) {
             await bot.sendMessage(validatedChatId, `📦 CLI published: v${publishResult.version}`);
         }
@@ -260,9 +264,10 @@ bot.onText(/\/publishcli/, async (msg) => {
         return;
     }
     const state = storage.load();
+    const mirrorUrls = storage.getAllMirrorUrls();
     const preview = formatCliPreview(state.versions);
     await bot.sendMessage(validatedChatId, `📦 Publishing CLI...\n\n${preview}`);
-    const result = await cliPublisher.publish(state.versions);
+    const result = await cliPublisher.publish(state.versions, mirrorUrls);
     if (result.success) {
         await bot.sendMessage(validatedChatId, `✅ CLI published: v${result.version}`);
     }
@@ -270,6 +275,25 @@ bot.onText(/\/publishcli/, async (msg) => {
         await bot.sendMessage(validatedChatId, `❌ CLI publish failed: ${result.error}`);
     }
 });
+bot.onText(/\/mirrorvsix(?:\s+(.+))?/, async (msg, match) => {
+    if (msg.chat.id.toString() !== validatedChatId)
+        return;
+    const versionArg = match?.[1]?.trim();
+    const version = versionArg || storage.getVersion('Claude Code VSCode');
+    if (!version) {
+        await bot.sendMessage(validatedChatId, 'No version specified and no tracked version found. Usage: /mirrorvsix [version]');
+        return;
+    }
+    await bot.sendMessage(validatedChatId, `Mirroring Claude Code VSCode v${version}...`);
+    const result = await vsixMirror.mirror(version);
+    if (result.success) {
+        storage.setMirrorUrl('Claude Code VSCode', result.downloadUrl);
+        await bot.sendMessage(validatedChatId, `✅ Mirrored successfully\nURL: ${result.downloadUrl}`);
+    }
+    else {
+        await bot.sendMessage(validatedChatId, `❌ Mirror failed: ${result.error}`);
+    }
+});
 // Start scheduled checks
 scheduleChecks(configData.checkIntervalHours);
 console.log(`ReleaseRadar started. Checking every ${configData.checkIntervalHours} hours.`);

package/dist/storage.d.ts

@@ -1,6 +1,7 @@
 export interface StorageState {
     lastCheck: string | null;
     versions: Record<string, string>;
+    mirrorUrls?: Record<string, string>;
 }
 export declare class Storage {
     private filePath;
@@ -11,4 +12,7 @@ export declare class Storage {
     save(state: StorageState): void;
     getVersion(toolName: string): string | null;
     setVersion(toolName: string, version: string): void;
+    getMirrorUrl(toolName: string): string | null;
+    setMirrorUrl(toolName: string, url: string): void;
+    getAllMirrorUrls(): Record<string, string>;
 }

package/dist/storage.js

@@ -34,4 +34,20 @@ export class Storage {
         state.lastCheck = new Date().toISOString();
         this.save(state);
     }
+    getMirrorUrl(toolName) {
+        const state = this.ensureLoaded();
+        return state.mirrorUrls?.[toolName] ?? null;
+    }
+    setMirrorUrl(toolName, url) {
+        const state = this.ensureLoaded();
+        if (!state.mirrorUrls) {
+            state.mirrorUrls = {};
+        }
+        state.mirrorUrls[toolName] = url;
+        this.save(state);
+    }
+    getAllMirrorUrls() {
+        const state = this.ensureLoaded();
+        return state.mirrorUrls ?? {};
+    }
 }

package/dist/storage.test.js

@@ -50,4 +50,33 @@ describe('Storage', () => {
         const newStorage = new Storage(testPath);
         expect(newStorage.getVersion('Ninja')).toBe('1.12.0');
     });
+    it('getMirrorUrl returns null for unknown tool', () => {
+        expect(storage.getMirrorUrl('Unknown')).toBeNull();
+    });
+    it('getMirrorUrl returns stored mirror URL', () => {
+        const state = {
+            lastCheck: null,
+            versions: {},
+            mirrorUrls: { 'Claude Code VSCode': 'github.com/lvntbkdmr/apps/releases/download/v1/file.vsix' }
+        };
+        writeFileSync(testPath, JSON.stringify(state));
+        storage = new Storage(testPath);
+        expect(storage.getMirrorUrl('Claude Code VSCode')).toBe('github.com/lvntbkdmr/apps/releases/download/v1/file.vsix');
+    });
+    it('setMirrorUrl updates and persists', () => {
+        storage.setMirrorUrl('Claude Code VSCode', 'github.com/test/url.vsix');
+        const newStorage = new Storage(testPath);
+        expect(newStorage.getMirrorUrl('Claude Code VSCode')).toBe('github.com/test/url.vsix');
+    });
+    it('getAllMirrorUrls returns empty object when none set', () => {
+        expect(storage.getAllMirrorUrls()).toEqual({});
+    });
+    it('getAllMirrorUrls returns all stored mirror URLs', () => {
+        storage.setMirrorUrl('Tool1', 'url1');
+        storage.setMirrorUrl('Tool2', 'url2');
+        expect(storage.getAllMirrorUrls()).toEqual({
+            'Tool1': 'url1',
+            'Tool2': 'url2'
+        });
+    });
 });

package/dist/versions-generator.d.ts

@@ -1,2 +1,2 @@
 import type { DownloadsConfig, VersionsJson } from './types.js';
-export declare function generateVersionsJson(versions: Record<string, string>, downloads: DownloadsConfig): VersionsJson;
+export declare function generateVersionsJson(versions: Record<string, string>, downloads: DownloadsConfig, mirrorUrls?: Record<string, string>): VersionsJson;

package/dist/versions-generator.js

@@ -8,7 +8,7 @@ function applyVersionPlaceholders(template, version) {
         .replace(/\{\{VERSION\}\}/g, version)
         .replace(/\{\{VERSION_BASE\}\}/g, getVersionBase(version));
 }
-export function generateVersionsJson(versions, downloads) {
+export function generateVersionsJson(versions, downloads, mirrorUrls = {}) {
     const tools = [];
     for (const [toolName, version] of Object.entries(versions)) {
         const downloadConfig = downloads[toolName];
@@ -26,18 +26,39 @@ export function generateVersionsJson(versions, downloads) {
             });
         }
         else {
-            // download type (default)
-            const downloadUrl = '{{NEXUS_URL}}/' +
-                applyVersionPlaceholders(downloadConfig.downloadUrl, version);
-            const filename = applyVersionPlaceholders(downloadConfig.filename, version);
-            tools.push({
-                name: toolName,
-                displayName: downloadConfig.displayName,
-                version,
-                publishedAt: new Date().toISOString(),
-                downloadUrl,
-                filename,
-            });
+            // Check if this uses MIRROR_URL placeholder
+            if (downloadConfig.downloadUrl === '{{MIRROR_URL}}') {
+                const mirrorUrl = mirrorUrls[toolName];
+                if (!mirrorUrl) {
+                    // Skip this tool - no mirror URL available
+                    console.log(`[versions-generator] Skipping ${toolName}: no mirror URL available`);
+                    continue;
+                }
+                const downloadUrl = '{{NEXUS_URL}}/' + mirrorUrl;
+                const filename = applyVersionPlaceholders(downloadConfig.filename, version);
+                tools.push({
+                    name: toolName,
+                    displayName: downloadConfig.displayName,
+                    version,
+                    publishedAt: new Date().toISOString(),
+                    downloadUrl,
+                    filename,
+                });
+            }
+            else {
+                // download type (default) with version template
+                const downloadUrl = '{{NEXUS_URL}}/' +
+                    applyVersionPlaceholders(downloadConfig.downloadUrl, version);
+                const filename = applyVersionPlaceholders(downloadConfig.filename, version);
+                tools.push({
+                    name: toolName,
+                    displayName: downloadConfig.displayName,
+                    version,
+                    publishedAt: new Date().toISOString(),
+                    downloadUrl,
+                    filename,
+                });
+            }
         }
     }
     return {

package/dist/versions-generator.test.js

@@ -82,4 +82,46 @@ describe('generateVersionsJson', () => {
         expect(ralphy.package).toBe('ralphy-cli');
         expect(ralphy.downloadUrl).toBeUndefined();
     });
+    it('uses mirrorUrls for MIRROR_URL placeholder', () => {
+        const versions = {
+            'Claude Code VSCode': '2.1.9',
+        };
+        const downloads = {
+            'Claude Code VSCode': {
+                displayName: 'Claude Code Extension',
+                downloadUrl: '{{MIRROR_URL}}',
+                filename: 'claude-code-{{VERSION}}-win32-x64.vsix',
+            },
+        };
+        const mirrorUrls = {
+            'Claude Code VSCode': 'github.com/lvntbkdmr/apps/releases/download/claude-code-vsix-v2.1.9/claude-code-2.1.9-win32-x64.vsix',
+        };
+        const result = generateVersionsJson(versions, downloads, mirrorUrls);
+        expect(result.tools).toHaveLength(1);
+        const tool = result.tools[0];
+        expect(tool.downloadUrl).toBe('{{NEXUS_URL}}/github.com/lvntbkdmr/apps/releases/download/claude-code-vsix-v2.1.9/claude-code-2.1.9-win32-x64.vsix');
+        expect(tool.filename).toBe('claude-code-2.1.9-win32-x64.vsix');
+    });
+    it('skips tool with MIRROR_URL placeholder when no mirrorUrl available', () => {
+        const versions = {
+            'Claude Code VSCode': '2.1.9',
+            'Ninja': '1.12.0',
+        };
+        const downloads = {
+            'Claude Code VSCode': {
+                displayName: 'Claude Code Extension',
+                downloadUrl: '{{MIRROR_URL}}',
+                filename: 'claude-code-{{VERSION}}-win32-x64.vsix',
+            },
+            'Ninja': {
+                displayName: 'Ninja',
+                downloadUrl: 'github.com/ninja/releases/{{VERSION}}/ninja.zip',
+                filename: 'ninja-{{VERSION}}.zip',
+            },
+        };
+        // No mirrorUrls provided for Claude Code VSCode
+        const result = generateVersionsJson(versions, downloads, {});
+        expect(result.tools).toHaveLength(1);
+        expect(result.tools[0].name).toBe('Ninja');
+    });
 });

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.7.13",
+  "version": "1.7.14",
   "description": "Monitor tool versions and notify via Telegram when updates are detected",
   "main": "dist/index.js",
   "bin": {