@lvnt/release-radar 1.7.16 → 1.9.0

package/dist/asset-mirror.test.js

@@ -12,7 +12,7 @@ vi.mock('fs', () => ({
 describe('AssetMirror', () => {
     let mirror;
     beforeEach(() => {
-        vi.clearAllMocks();
+        vi.resetAllMocks();
         mirror = new AssetMirror();
     });
     describe('buildTag', () => {
@@ -74,11 +74,56 @@ describe('AssetMirror', () => {
             vi.mocked(execSync).mockReturnValueOnce('');
             vi.mocked(existsSync).mockReturnValue(true);
             const result = await mirror.mirror('Claude Code VSCode', '2.1.9', {
-                sourceUrl: 'marketplace-api'
+                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(() => {

package/dist/checker.d.ts

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

package/dist/checker.js

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

package/dist/checker.test.js

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

package/dist/index.js

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

package/dist/mirror-and-publish.js

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

package/dist/types.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvnt/release-radar",
-  "version": "1.7.16",
+  "version": "1.9.0",
   "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 });
-    }
-}