imcp 0.0.12 → 0.0.14

package/dist/core/installers/clients/ClientInstaller.js

@@ -276,6 +276,7 @@ export class ClientInstaller {
             // --- Start of new logic ---
             // Clone the base installation configuration to avoid modifying the original serverConfig
             const installConfig = JSON.parse(JSON.stringify(serverConfig.installation));
+            installConfig.mode = serverConfig.mode;
             const pythonEnv = options.settings?.pythonEnv;
             let pythonDir = null;
             // 1. Determine which args to use and resolve npm paths
@@ -499,39 +500,48 @@ export class ClientInstaller {
         if (!settings.mcpServers) {
             settings.mcpServers = {};
         }
-        // Special handling for Windows when command is npx for Cline and MSROO clients
-        // Use a copy to avoid modifying the passed installConfig directly if needed elsewhere
-        const serverConfigForClient = { ...installConfig };
-        if (process.platform === 'win32' &&
-            serverConfigForClient.command === 'npx' &&
-            (clientName === 'Cline' || clientName === 'MSRooCode' || clientName === 'MSROO')) {
-            // Update command to cmd
-            serverConfigForClient.command = 'cmd';
-            // Add /c and npx at the beginning of args
-            serverConfigForClient.args = ['/c', 'npx', ...serverConfigForClient.args];
-            // Add APPDATA environment variable pointing to npm directory
-            if (!serverConfigForClient.env) {
-                serverConfigForClient.env = {};
+        if (installConfig.mode === 'stdio') {
+            // Special handling for Windows when command is npx for Cline and MSROO clients
+            // Use a copy to avoid modifying the passed installConfig directly if needed elsewhere
+            const serverConfigForClient = { ...installConfig };
+            if (process.platform === 'win32' &&
+                serverConfigForClient.command === 'npx' &&
+                (clientName === 'Cline' || clientName === 'MSRooCode' || clientName === 'MSROO')) {
+                // Update command to cmd
+                serverConfigForClient.command = 'cmd';
+                // Add /c and npx at the beginning of args
+                serverConfigForClient.args = ['/c', 'npx', ...serverConfigForClient.args];
+                // Add APPDATA environment variable pointing to npm directory
+                if (!serverConfigForClient.env) {
+                    serverConfigForClient.env = {};
+                }
+                // Dynamically get npm path and set APPDATA to it
+                const npmPath = await this.getNpmPath();
+                serverConfigForClient.env['APPDATA'] = npmPath;
+                Logger.debug(`Windows npx fix: command=${serverConfigForClient.command}, args=${serverConfigForClient.args.join(' ')}, env=${JSON.stringify(serverConfigForClient.env)}`);
+            }
+            // Convert backslashes to forward slashes in args paths
+            if (serverConfigForClient.args) {
+                serverConfigForClient.args = serverConfigForClient.args.map((arg) => typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg);
             }
-            // Dynamically get npm path and set APPDATA to it
-            const npmPath = await this.getNpmPath();
-            serverConfigForClient.env['APPDATA'] = npmPath;
-            Logger.debug(`Windows npx fix: command=${serverConfigForClient.command}, args=${serverConfigForClient.args.join(' ')}, env=${JSON.stringify(serverConfigForClient.env)}`);
+            // Add or update the server configuration
+            settings.mcpServers[serverName] = {
+                command: serverConfigForClient.command,
+                args: serverConfigForClient.args,
+                env: serverConfigForClient.env,
+                autoApprove: [],
+                disabled: false,
+                alwaysAllow: []
+            };
+            Logger.debug(`Updating ${settingPath} for ${serverName}: ${JSON.stringify(settings.mcpServers[serverName])}`);
         }
-        // Convert backslashes to forward slashes in args paths
-        if (serverConfigForClient.args) {
-            serverConfigForClient.args = serverConfigForClient.args.map((arg) => typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg);
+        else if (installConfig.mode === 'sse') {
+            // Handle SSE mode for Cline and MSRoo clients
+            settings.mcpServers[serverName] = {
+                type: 'sse',
+                url: installConfig.url
+            };
         }
-        // Add or update the server configuration
-        settings.mcpServers[serverName] = {
-            command: serverConfigForClient.command,
-            args: serverConfigForClient.args,
-            env: serverConfigForClient.env,
-            autoApprove: [],
-            disabled: false,
-            alwaysAllow: []
-        };
-        Logger.debug(`Updating ${settingPath} for ${serverName}: ${JSON.stringify(settings.mcpServers[serverName])}`);
         // Write the updated settings back to the file
         await writeJsonFile(settingPath, settings);
     }
@@ -551,17 +561,25 @@ export class ClientInstaller {
         }
         // Use a copy to avoid modifying the passed installConfig directly
         const serverConfigForClient = { ...installConfig };
-        // Convert backslashes to forward slashes in args paths
-        if (serverConfigForClient.args) {
-            serverConfigForClient.args = serverConfigForClient.args.map((arg) => typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg);
+        if (installConfig.mode === 'stdio') {
+            if (serverConfigForClient.args) {
+                serverConfigForClient.args = serverConfigForClient.args.map((arg) => typeof arg === 'string' ? arg.replace(/\\/g, '/') : arg);
+            }
+            // Add or update the server configuration
+            settings.mcp.servers[serverName] = {
+                command: serverConfigForClient.command,
+                args: serverConfigForClient.args,
+                env: serverConfigForClient.env
+            };
+            Logger.debug(`Updating ${settingPath} for ${serverName}: ${JSON.stringify(settings.mcp.servers[serverName])}`);
+        }
+        else if (installConfig.mode === 'sse') {
+            // Handle SSE mode for Github Copilot
+            settings.mcp.servers[serverName] = {
+                type: 'sse',
+                url: installConfig.url
+            };
         }
-        // Add or update the server configuration
-        settings.mcp.servers[serverName] = {
-            command: serverConfigForClient.command,
-            args: serverConfigForClient.args,
-            env: serverConfigForClient.env
-        };
-        Logger.debug(`Updating ${settingPath} for ${serverName}: ${JSON.stringify(settings.mcp.servers[serverName])}`);
         // Write the updated settings back to the file
         await writeJsonFile(settingPath, settings);
     }

package/dist/core/installers/requirements/PipInstaller.js

@@ -21,7 +21,7 @@ export class PipInstaller extends BaseInstaller {
     }
     supportCheckUpdates() {
         /// temporarily disabling update check for pip as not able to get which pip of python is being used
-        return false;
+        return true;
     }
     /**
      * Check if the Python package is already installed
@@ -41,7 +41,8 @@ export class PipInstaller extends BaseInstaller {
                 type: 'pip',
                 installed,
                 version: installedVersion,
-                inProgress: false
+                inProgress: false,
+                pythonEnv: this.getPythonCommand(options) // Preserve pythonEnv in status check too
             };
         }
         catch (error) {
@@ -50,7 +51,8 @@ export class PipInstaller extends BaseInstaller {
                 type: 'pip',
                 installed: false,
                 error: error instanceof Error ? error.message : String(error),
-                inProgress: false
+                inProgress: false,
+                pythonEnv: this.getPythonCommand(options) // Preserve pythonEnv even in error case
             };
         }
     }
@@ -106,12 +108,14 @@ export class PipInstaller extends BaseInstaller {
                     throw new Error('Invalid registry configuration');
                 }
             }
+            // Store the pythonEnv in the status for future use
             return {
                 name: requirement.name,
                 type: 'pip',
                 installed: true,
                 version: requirement.version,
-                inProgress: false
+                inProgress: false,
+                pythonEnv: this.getPythonCommand(options) // Store the python env
             };
         }
         catch (error) {
@@ -120,7 +124,8 @@ export class PipInstaller extends BaseInstaller {
                 type: 'pip',
                 installed: false,
                 error: error instanceof Error ? error.message : String(error),
-                inProgress: false
+                inProgress: false,
+                pythonEnv: this.getPythonCommand(options) // Store the python env
             };
         }
     }

package/dist/core/onboard/FeedOnboardService.d.ts

@@ -0,0 +1,35 @@
+import { FeedConfiguration } from '../types.js';
+/**
+ * Service for handling feed onboarding operations
+ */
+export declare class FeedOnboardService {
+    private tempDir;
+    private repoDir;
+    constructor();
+    /**
+     * Onboard a new feed configuration
+     * @param config Feed configuration to onboard
+     */
+    onboardFeed(config: FeedConfiguration): Promise<void>;
+    /**
+     * Fork the repository using gh CLI
+     */
+    private forkRepo;
+    /**
+     * Clone the forked repository
+     */
+    private cloneRepo;
+    /**
+     * Get GitHub username using gh CLI
+     */
+    private getGitHubUsername;
+    /**
+     * Save feed configuration to file
+     */
+    private saveFeedConfig;
+    /**
+     * Create pull request using gh CLI
+     */
+    private createPullRequest;
+}
+export declare const feedOnboardService: FeedOnboardService;

package/dist/core/onboard/FeedOnboardService.js

@@ -0,0 +1,137 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs/promises';
+import path from 'path';
+import { GITHUB_REPO, SETTINGS_DIR } from '../constants.js';
+import { feedValidator } from '../validators/FeedValidator.js';
+import { Logger } from '../../utils/logger.js';
+const execAsync = promisify(exec);
+/**
+ * Service for handling feed onboarding operations
+ */
+export class FeedOnboardService {
+    tempDir;
+    repoDir;
+    constructor() {
+        this.tempDir = path.join(SETTINGS_DIR, 'temp');
+        this.repoDir = path.join(this.tempDir, 'imcp-feed');
+    }
+    /**
+     * Onboard a new feed configuration
+     * @param config Feed configuration to onboard
+     */
+    async onboardFeed(config) {
+        try {
+            // Validate feed configuration
+            feedValidator.validate(config);
+            // Create temp directory
+            await fs.mkdir(this.tempDir, { recursive: true });
+            // Fork the repo
+            await this.forkRepo();
+            // Clone the forked repo
+            await this.cloneRepo();
+            // Save feed configuration
+            await this.saveFeedConfig(config);
+            // Create branch, push changes and create PR
+            await this.createPullRequest(config);
+            Logger.log(`Successfully onboarded feed: ${config.name}`);
+        }
+        catch (error) {
+            Logger.error('Feed onboarding failed:', error);
+            throw error;
+        }
+        finally {
+            // Cleanup temp directory
+            await fs.rm(this.tempDir, { recursive: true, force: true });
+        }
+    }
+    /**
+     * Fork the repository using gh CLI
+     */
+    async forkRepo() {
+        try {
+            await execAsync(`gh repo fork ${GITHUB_REPO.repoName} --clone=false`);
+            Logger.debug('Successfully forked repository');
+        }
+        catch (error) {
+            throw new Error(`Failed to fork repository: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Clone the forked repository
+     */
+    async cloneRepo() {
+        try {
+            // Clean up existing repo directory
+            await fs.rm(this.repoDir, { recursive: true, force: true });
+            const username = await this.getGitHubUsername();
+            const repoUrl = `https://github.com/${username}/${GITHUB_REPO.repoName.split('/')[1]}.git`;
+            // Ensure temp dir exists
+            await fs.mkdir(this.tempDir, { recursive: true });
+            // Clone the repo into imcp-feed subdirectory
+            await execAsync(`git clone ${repoUrl} ${this.repoDir}`);
+            Logger.debug('Successfully cloned repository');
+        }
+        catch (error) {
+            throw new Error(`Failed to clone repository: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get GitHub username using gh CLI
+     */
+    async getGitHubUsername() {
+        try {
+            const { stdout } = await execAsync('gh api user -q .login');
+            return stdout.trim();
+        }
+        catch (error) {
+            throw new Error(`Failed to get GitHub username: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Save feed configuration to file
+     */
+    async saveFeedConfig(config) {
+        try {
+            const feedsDir = path.join(this.repoDir, GITHUB_REPO.feedsPath);
+            await fs.mkdir(feedsDir, { recursive: true });
+            const configPath = path.join(feedsDir, `${config.name}.json`);
+            await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+            Logger.debug(`Saved feed configuration to ${configPath}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to save feed configuration: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Create pull request using gh CLI
+     */
+    async createPullRequest(config) {
+        try {
+            process.chdir(this.repoDir);
+            // Ensure we're up to date with upstream main
+            await execAsync(`git remote add upstream ${GITHUB_REPO.url}`);
+            await execAsync('git fetch upstream');
+            await execAsync('git reset --hard upstream/main');
+            // Create and checkout new branch
+            const branchName = `feed/${config.name}`;
+            await execAsync(`git checkout -b ${branchName}`);
+            // Stage and commit changes
+            await execAsync('git add .');
+            await execAsync(`git commit -m "Add feed configuration for ${config.name}"`);
+            // Push to origin
+            await execAsync(`git push -f origin ${branchName}`);
+            const title = `Add feed configuration for ${config.name}`;
+            const body = `Add new feed configuration:\n\n- Name: ${config.name}\n- Display Name: ${config.displayName}\n- Description: ${config.description}`;
+            const username = await this.getGitHubUsername();
+            await execAsync(`gh pr create --title "${title}" --body "${body}" --repo ${GITHUB_REPO.repoName} --base main --head ${username}:${branchName}`);
+            Logger.debug('Successfully created pull request');
+        }
+        catch (error) {
+            throw new Error(`Failed to create pull request: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+// Export singleton instance
+export const feedOnboardService = new FeedOnboardService();
+//# sourceMappingURL=FeedOnboardService.js.map

package/dist/core/types.d.ts

@@ -16,6 +16,7 @@ export interface RequirementStatus {
     };
     lastCheckTime?: string;
     operationStatus?: OperationStatus;
+    pythonEnv?: string;
 }
 export interface MCPServerStatus {
     installedStatus: Record<string, OperationStatus>;
@@ -84,6 +85,7 @@ export interface InstallationConfig {
     command: string;
     args: string[];
     env?: Record<string, EnvVariableConfig>;
+    url?: string;
 }
 export interface DependencyConfig {
     requirements?: Array<{
@@ -98,8 +100,10 @@ export interface DependencyConfig {
 export interface McpConfig {
     name: string;
     description: string;
-    mode: 'stdio' | 'http';
+    mode: 'stdio' | 'sse';
     dependencies?: DependencyConfig;
+    schemas?: string;
+    repository?: string;
     installation: InstallationConfig;
 }
 export interface RegistryConfig {
@@ -128,6 +132,7 @@ export interface FeedConfiguration {
     name: string;
     displayName: string;
     description: string;
+    repository?: string;
     requirements: RequirementConfig[];
     mcpServers: McpConfig[];
 }

package/dist/core/validators/FeedValidator.d.ts

@@ -0,0 +1,13 @@
+import { FeedConfiguration } from "../types.js";
+/**
+ * Validates feed configurations to ensure they meet required criteria
+ */
+export declare class FeedValidator {
+    /**
+     * Validates a feed configuration
+     * @param config The feed configuration to validate
+     * @returns true if valid, throws error if invalid
+     */
+    validate(config: FeedConfiguration): boolean;
+}
+export declare const feedValidator: FeedValidator;

package/dist/core/validators/FeedValidator.js

@@ -0,0 +1,27 @@
+/**
+ * Validates feed configurations to ensure they meet required criteria
+ */
+export class FeedValidator {
+    /**
+     * Validates a feed configuration
+     * @param config The feed configuration to validate
+     * @returns true if valid, throws error if invalid
+     */
+    validate(config) {
+        try {
+            // For now return true as requested
+            return true;
+            // TODO: Implement full validation logic:
+            // - Required fields (name, displayName, etc)
+            // - Server configuration validation
+            // - Requirements validation
+            // - Repository validation
+        }
+        catch (error) {
+            throw new Error(`Feed validation failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+// Export singleton instance
+export const feedValidator = new FeedValidator();
+//# sourceMappingURL=FeedValidator.js.map

package/dist/services/ServerService.d.ts

@@ -1,3 +1,4 @@
+import { ServerSchema } from '../core/ServerSchemaProvider.js';
 import { MCPServerCategory, ServerInstallOptions, ServerCategoryListOptions, ServerOperationResult, ServerUninstallOptions } from '../core/types.js';
 /**
  * ServerService provides a unified interface for server management operations.
@@ -18,6 +19,10 @@ export declare class ServerService {
      * @private
      */
     private checkRequirementsForUpdate;
+    /**
+     * Gets the schema for a specific server in a category
+     */
+    getServerSchema(categoryName: string, serverName: string): Promise<ServerSchema | undefined>;
     /**
      * Installs a specific mcp tool for a server.
      * TODO: This might require enhancing MCPManager to handle category-specific installs.

package/dist/services/ServerService.js

@@ -1,6 +1,7 @@
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { Logger } from '../utils/logger.js';
+import { getServerSchemaProvider } from '../core/ServerSchemaProvider.js';
 import { mcpManager } from '../core/MCPManager.js';
 import { UPDATE_CHECK_INTERVAL_MS } from '../core/constants.js';
 import { updateCheckTracker } from '../utils/UpdateCheckTracker.js';
@@ -96,6 +97,20 @@ export class ServerService {
             }
         }
     }
+    /**
+     * Gets the schema for a specific server in a category
+     */
+    async getServerSchema(categoryName, serverName) {
+        try {
+            const provider = await getServerSchemaProvider();
+            const serverMcpConfig = await mcpManager.getServerMcpConfig(categoryName, serverName);
+            return await provider.getSchema(categoryName, serverMcpConfig?.schemas || `${serverName}.json`);
+        }
+        catch (error) {
+            Logger.error(`Failed to get schema for server ${serverName} in category ${categoryName}:`, error);
+            throw error;
+        }
+    }
     /**
      * Installs a specific mcp tool for a server.
      * TODO: This might require enhancing MCPManager to handle category-specific installs.

package/dist/utils/githubAuth.js

@@ -29,16 +29,6 @@ class GithubAuthError extends Error {
 export async function checkGithubAuth() {
     Logger.debug('Starting GitHub authentication check');
     try {
-        // Check if git is installed
-        if (!await isToolInstalled('git')) {
-            Logger.log('Installing required Git...');
-            await installCLI('git');
-            // Verify git was installed correctly, with retry mechanism
-            if (!await isToolInstalled('git')) {
-                throw new Error('Failed to install Git. Please install it manually and try again.');
-            }
-            Logger.debug('Git installed successfully and verified');
-        }
         // Check if gh CLI is installed
         if (!await isToolInstalled('gh')) {
             Logger.log('Installing required GitHub CLI...');

package/dist/utils/githubUtils.d.ts

@@ -1,4 +1,19 @@
 import { RegistryConfig, RequirementConfig } from '../core/types.js';
+interface DownloadGithubReleaseResult {
+    version: string;
+    downloadPath: string;
+}
+/**
+ * Downloads a GitHub release asset
+ * @param repo GitHub repository in format owner/repo
+ * @param version Version to download, can be "latest"
+ * @param assetsName Assets name pattern (optional, but either assetsName or assetName must be provided)
+ * @param assetName Asset name pattern (optional, but either assetsName or assetName must be provided)
+ * @param isFolder Whether to treat the downloaded asset as a folder (default: false)
+ * @param targetDirectory Target directory for downloads (default: SETTINGS_DIR/downloads)
+ * @returns Object containing version and download path
+ */
+export declare function downloadGithubRelease(repo: string, version: string, assetsName?: string, assetName?: string, isFolder?: boolean, targetDirectory?: string): Promise<DownloadGithubReleaseResult>;
 /**
  * Helper to handle GitHub release downloads
  * @param requirement The requirement configuration
@@ -9,3 +24,4 @@ export declare function handleGitHubRelease(requirement: RequirementConfig, regi
     resolvedVersion: string;
     resolvedPath: string;
 }>;
+export {};

package/dist/utils/githubUtils.js

@@ -3,78 +3,94 @@ import util from 'util';
 import fs from 'fs/promises';
 import path from 'path';
 import { extractZipFile } from './clientUtils.js';
-import { Logger } from './logger.js';
 import { SETTINGS_DIR } from '../core/constants.js';
 const execAsync = util.promisify(exec);
 /**
- * Helper to handle GitHub release downloads
- * @param requirement The requirement configuration
- * @param registry The GitHub release registry configuration
- * @returns The path to the downloaded file
+ * Downloads a GitHub release asset
+ * @param repo GitHub repository in format owner/repo
+ * @param version Version to download, can be "latest"
+ * @param assetsName Assets name pattern (optional, but either assetsName or assetName must be provided)
+ * @param assetName Asset name pattern (optional, but either assetsName or assetName must be provided)
+ * @param isFolder Whether to treat the downloaded asset as a folder (default: false)
+ * @param targetDirectory Target directory for downloads (default: SETTINGS_DIR/downloads)
+ * @returns Object containing version and download path
  */
-export async function handleGitHubRelease(requirement, registry) {
-    if (!registry) {
-        throw new Error('GitHub release registry configuration is required');
+export async function downloadGithubRelease(repo, version, assetsName, assetName, isFolder = false, targetDirectory) {
+    if (!repo) {
+        throw new Error('GitHub repository is required');
     }
-    const downloadsDir = path.join(SETTINGS_DIR, 'downloads');
-    await fs.mkdir(downloadsDir, { recursive: true });
-    const { repository, assetsName, assetName } = registry;
-    if (!repository) {
-        throw new Error('GitHub repository is required for GitHub release downloads');
+    if (!assetsName && !assetName) {
+        throw new Error('Either assetsName or assetName must be specified');
     }
-    let version = requirement.version;
-    let resolvedAssetName = assetName || '';
-    let resolvedAssetsName = assetsName || '';
-    const { stdout } = await execAsync(`gh release view --repo ${repository} --json tagName --jq .tagName`);
+    const downloadsDir = targetDirectory || path.join(SETTINGS_DIR, 'downloads');
+    await fs.mkdir(downloadsDir, { recursive: true });
+    // Get latest version if needed
+    const { stdout } = await execAsync(`gh release view --repo ${repo} --json tagName --jq .tagName`);
     const latestTag = stdout.trim();
     let latestVersion = latestTag;
     const tagWithVPrefix = latestVersion.startsWith('v');
     if (tagWithVPrefix)
         latestVersion = latestVersion.substring(1); // Remove 'v' prefix if present
-    version = version.includes("latest") ? latestVersion : version;
+    const resolvedVersion = version.includes("latest") ? latestVersion : version;
+    // Resolve asset names
+    let resolvedAssetsName = '';
+    let resolvedAssetName = '';
     if (assetsName) {
-        resolvedAssetsName = assetsName.replace('${latest}', version).replace('${version}', version);
+        resolvedAssetsName = assetsName.replace('${latest}', resolvedVersion).replace('${version}', resolvedVersion);
     }
     if (assetName) {
-        resolvedAssetName = assetName.replace('${latest}', version).replace('${version}', version);
+        resolvedAssetName = assetName.replace('${latest}', resolvedVersion).replace('${version}', resolvedVersion);
     }
-    Logger.debug(`Downloading ${requirement.name} from GitHub release ${repository} version ${version}`);
-    Logger.debug(`ResolvedAssetsName} ${resolvedAssetName}; ResolvedAsetName} ${resolvedAssetName}`);
-    const pattern = resolvedAssetsName ? resolvedAssetsName : resolvedAssetName;
-    Logger.debug(`Resolved pattern: ${pattern}`);
-    if (!pattern) {
-        throw new Error('Either assetsName or assetName must be specified for GitHub release downloads');
+    // Validate zip requirement for isFolder
+    const pattern = resolvedAssetsName || resolvedAssetName;
+    if (isFolder && (!resolvedAssetsName || !resolvedAssetsName.endsWith('.zip'))) {
+        throw new Error('When isFolder is true, assetsName must be provided and end with .zip');
     }
     // Download the release asset
     const downloadPath = path.join(downloadsDir, path.basename(pattern));
     if (!await fileExists(downloadPath)) {
-        await execAsync(`gh release download ${tagWithVPrefix ? `v${version}` : version} --repo ${repository} --pattern "${pattern}" -O "${downloadPath}"`);
+        await execAsync(`gh release download ${tagWithVPrefix ? `v${resolvedVersion}` : resolvedVersion} --repo ${repo} --pattern "${pattern}" -O "${downloadPath}"`);
     }
-    // Handle zip file extraction if the downloaded file is a zip
-    if (downloadPath.endsWith('.zip')) {
+    // Handle zip extraction if needed
+    if (isFolder && downloadPath.endsWith('.zip')) {
         const extractDir = path.join(downloadsDir, path.basename(pattern, '.zip'));
         await fs.mkdir(extractDir, { recursive: true });
-        // Extract the zip file
         await extractZipFile(downloadPath, { dir: extractDir });
-        let assetPath = '';
         // If resolvedAssetName is specified, look for it in the extracted directory
         if (resolvedAssetName) {
-            assetPath = path.join(extractDir, resolvedAssetName);
+            const assetPath = path.join(extractDir, resolvedAssetName);
             try {
                 await fs.access(assetPath);
-                return { resolvedVersion: version, resolvedPath: assetPath };
+                return { version: resolvedVersion, downloadPath: assetPath };
             }
             catch (error) {
                 throw new Error(`Asset ${resolvedAssetName} not found in extracted directory ${extractDir}`);
             }
         }
-        else {
-            assetPath = path.join(extractDir, path.basename(pattern, '.zip') + '.tgz');
-        }
-        // If no specific asset is required, return the extraction directory
-        return { resolvedVersion: version, resolvedPath: extractDir };
+        return { version: resolvedVersion, downloadPath: extractDir };
+    }
+    return { version: resolvedVersion, downloadPath };
+}
+/**
+ * Helper to handle GitHub release downloads
+ * @param requirement The requirement configuration
+ * @param registry The GitHub release registry configuration
+ * @returns The path to the downloaded file
+ */
+export async function handleGitHubRelease(requirement, registry) {
+    if (!registry) {
+        throw new Error('GitHub release registry configuration is required');
+    }
+    const { repository, assetsName, assetName } = registry;
+    if (!repository) {
+        throw new Error('GitHub repository is required for GitHub release downloads');
     }
-    return { resolvedVersion: version, resolvedPath: downloadPath };
+    const isZipAsset = assetsName?.endsWith('.zip') || false;
+    const result = await downloadGithubRelease(repository, requirement.version, assetsName, assetName, isZipAsset);
+    return {
+        resolvedVersion: result.version,
+        resolvedPath: result.downloadPath
+    };
 }
 async function fileExists(filePath) {
     try {