imcp 0.0.3 → 0.0.5

package/src/core/installers/{BaseInstaller.ts → requirements/BaseInstaller.ts}

@@ -1,10 +1,10 @@
-import { RequirementConfig, RequirementStatus, RegistryConfig } from '../types.js';
+import { RequirementConfig, RequirementStatus, RegistryConfig, ServerInstallOptions } from '../../types.js';
 import path from 'path';
 import fs from 'fs/promises';
-import { SETTINGS_DIR } from '../constants.js';
-import { extractZipFile } from '../../utils/clientUtils.js';
+import { SETTINGS_DIR } from '../../constants.js';
+import { extractZipFile } from '../../../utils/clientUtils.js';
 import { RequirementInstaller } from './RequirementInstaller.js';
-import { Logger } from '../../utils/logger.js';
+import { Logger } from '../../../utils/logger.js';
 
 /**
  * Abstract base class with common functionality for all requirement installers
@@ -19,8 +19,9 @@ export abstract class BaseInstaller implements RequirementInstaller {
     }
 
     abstract canHandle(requirement: RequirementConfig): boolean;
-    abstract install(requirement: RequirementConfig): Promise<RequirementStatus>;
-    abstract checkInstallation(requirement: RequirementConfig): Promise<RequirementStatus>;
+    abstract supportCheckUpdates(): boolean;
+    abstract install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
+    abstract checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
 
     /**
      * Check if updates are available for the requirement
@@ -82,107 +83,6 @@ export abstract class BaseInstaller implements RequirementInstaller {
         }
     }
 
-    /**
-     * Helper method to ensure downloads directory exists
-     */
-    protected async ensureDownloadsDir(): Promise<void> {
-        await fs.mkdir(this.downloadsDir, { recursive: true });
-    }
-
-    /**
-     * 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
-     */
-    protected async handleGitHubRelease(
-        requirement: RequirementConfig,
-        registry: RegistryConfig['githubRelease']
-    ): Promise<{ resolvedVersion: string; resolvedPath: string }> {
-        if (!registry) {
-            throw new Error('GitHub release registry configuration is required');
-        }
-
-        await this.ensureDownloadsDir();
-        const { repository, assetsName, assetName } = registry;
-
-        if (!repository) {
-            throw new Error('GitHub repository is required for GitHub release downloads');
-        }
-
-        let version = requirement.version;
-        let resolvedAssetName = assetName || '';
-        let resolvedAssetsName = assetsName || '';
-
-        const { stdout } = await this.execPromise(`gh release view --repo ${repository} --json tagName --jq .tagName`);
-        const latestTag = stdout.trim();
-        // Handle latest version detection
-        if (version.includes('${latest}') || version === 'latest') {
-
-            let latestVersion = latestTag
-            if (latestVersion.startsWith('v') && version.startsWith('v')) {
-                latestVersion = latestVersion.substring(1); // Remove 'v' prefix if present
-                // Replace ${latest} in version and asset names
-                version = version.replace('${latest}', latestVersion);
-                if (assetsName) {
-                    resolvedAssetsName = assetsName.replace('${latest}', latestVersion).replace('${version}', version);
-                }
-                if (assetName) {
-                    resolvedAssetName = assetName.replace('${latest}', latestVersion).replace('${version}', version);
-                }
-            }
-        } else {
-            if (assetsName) {
-                resolvedAssetsName = assetsName.replace('${latest}', version).replace('${version}', version);
-            }
-            if (assetName) {
-                resolvedAssetName = assetName.replace('${latest}', version).replace('${version}', version);
-            }
-            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');
-        }
-
-        // Download the release asset
-        const downloadPath = path.join(this.downloadsDir, path.basename(pattern));
-        if (!await this.fileExists(downloadPath)) {
-            await this.execPromise(`gh release download ${version.startsWith('v') ? version : `v${version}`} --repo ${repository} --pattern "${pattern}" -O "${downloadPath}"`);
-        }
-
-        // Handle zip file extraction if the downloaded file is a zip
-        if (downloadPath.endsWith('.zip')) {
-            const extractDir = path.join(this.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);
-                try {
-                    await fs.access(assetPath);
-                    return { resolvedVersion: version, resolvedPath: 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 { resolvedVersion: version, resolvedPath: downloadPath };
-    }
-
     /**
      * Helper to handle artifact registry downloads
      * @param requirement The requirement configuration
@@ -254,15 +154,6 @@ export abstract class BaseInstaller implements RequirementInstaller {
         return localPath;
     }
 
-    private async fileExists(filePath: string): Promise<boolean> {
-        try {
-            await fs.access(filePath)
-            return true
-        } catch {
-            return false
-        }
-    }
-
     /**
      * Get the latest version available for a GitHub repository
      * @param repository The GitHub repository in format 'owner/repo'
@@ -301,8 +192,9 @@ export abstract class BaseInstaller implements RequirementInstaller {
      * @param packageName The name of the pip package
      * @returns The latest version
      */
-    protected async getPipLatestVersion(packageName: string): Promise<string> {
-        const { stdout } = await this.execPromise(`pip index versions ${packageName} --pre=0 | grep -oP "(?<=Latest:\\s)[^\\s]+" | head -1`);
+    protected async getPipLatestVersion(packageName: string, options?: ServerInstallOptions): Promise<string> {
+        const pythonCmd = options?.settings?.pythonEnv as string || 'python';
+        const { stdout } = await this.execPromise(`${pythonCmd} -m pip index versions ${packageName} --pre=0 | grep -oP "(?<=Latest:\\s)[^\\s]+" | head -1`);
         return stdout.trim();
     }
 }

package/src/core/installers/{CommandInstaller.ts → requirements/CommandInstaller.ts}

@@ -1,7 +1,7 @@
-import { RequirementConfig, RequirementStatus, OSType } from '../types.js';
+import { RequirementConfig, RequirementStatus, OSType } from '../../types.js';
 import { BaseInstaller } from './BaseInstaller.js';
-import { getOSType, refreshPathEnv } from '../../utils/osUtils.js';
-import { Logger } from '../../utils/logger.js';
+import { getOSType, refreshPathEnv } from '../../../utils/osUtils.js';
+import { Logger } from '../../../utils/logger.js';
 
 /**
  * Mapping of command names to their package IDs on different platforms
@@ -15,6 +15,7 @@ interface CommandMapping {
  * Installer implementation for command-line tools
  */
 export class CommandInstaller extends BaseInstaller {
+
     /**
      * Mapping of command names to their package IDs
      * This handles special cases where the command name differs from the package ID
@@ -33,6 +34,9 @@ export class CommandInstaller extends BaseInstaller {
         return requirement.type === 'command';
     }
 
+    supportCheckUpdates(): boolean {
+        return false;
+    }
     /**
      * Get the mapped package ID for a command
      * @param commandName The command name to map

package/src/core/installers/{GeneralInstaller.ts → requirements/GeneralInstaller.ts}

@@ -1,5 +1,6 @@
-import { RequirementConfig, RequirementStatus } from '../types.js';
+import { RequirementConfig, RequirementStatus } from '../../types.js';
 import { BaseInstaller } from './BaseInstaller.js';
+import { handleGitHubRelease } from '../../../utils/githubUtils.js';
 
 /**
  * Installer implementation for general requirements (type 'other')
@@ -15,6 +16,9 @@ export class GeneralInstaller extends BaseInstaller {
         return requirement.type === 'other';
     }
 
+    supportCheckUpdates(): boolean {
+        return false;
+    }
     /**
      * Check if the requirement is already installed
      * For general installers, we can't easily check if something is installed
@@ -52,7 +56,7 @@ export class GeneralInstaller extends BaseInstaller {
             let installPath: string;
 
             if (requirement.registry.githubRelease) {
-                const result = await this.handleGitHubRelease(requirement, requirement.registry.githubRelease);
+                const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
                 installPath = result.resolvedPath;
             } else if (requirement.registry.artifacts) {
                 installPath = await this.handleArtifactsRegistry(requirement, requirement.registry.artifacts);

package/src/core/installers/{InstallerFactory.ts → requirements/InstallerFactory.ts}

@@ -1,4 +1,4 @@
-import { RequirementConfig, RequirementStatus } from '../types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../types.js';
 import { RequirementInstaller } from './RequirementInstaller.js';
 import { NpmInstaller } from './NpmInstaller.js';
 import { PipInstaller } from './PipInstaller.js';
@@ -59,9 +59,10 @@ export class InstallerFactory {
     /**
      * Install a requirement using the appropriate installer
      * @param requirement The requirement to install
+     * @param options Installation options including python environment
      * @returns The installation status
      */
-    public async install(requirement: RequirementConfig): Promise<RequirementStatus> {
+    public async install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus> {
         const installer = this.getInstaller(requirement);
         if (!installer) {
             return {
@@ -73,15 +74,16 @@ export class InstallerFactory {
             };
         }
 
-        return await installer.install(requirement);
+        return await installer.install(requirement, options);
     }
 
     /**
-     * Check the installation status of a requirement
-     * @param requirement The requirement to check
-     * @returns The installation status
-     */
-    public async checkInstallation(requirement: RequirementConfig): Promise<RequirementStatus> {
+      * Check the installation status of a requirement
+      * @param requirement The requirement to check
+      * @param options Installation options including python environment
+      * @returns The installation status
+      */
+    public async checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus> {
         const installer = this.getInstaller(requirement);
         if (!installer) {
             return {
@@ -93,7 +95,7 @@ export class InstallerFactory {
             };
         }
 
-        return await installer.checkInstallation(requirement);
+        return await installer.checkInstallation(requirement, options);
     }
 }
 

package/src/core/installers/{NpmInstaller.ts → requirements/NpmInstaller.ts}

@@ -1,8 +1,8 @@
 import { stat } from 'fs';
-import { RequirementConfig, RequirementStatus } from '../types.js';
+import { RequirementConfig, RequirementStatus } from '../../types.js';
 import { BaseInstaller } from './BaseInstaller.js';
-import { compareVersions } from '../../utils/versionUtils.js';
-
+import { compareVersions } from '../../../utils/versionUtils.js';
+import { handleGitHubRelease } from '../../../utils/githubUtils.js';
 /**
  * Installer implementation for NPM packages
  */
@@ -16,6 +16,9 @@ export class NpmInstaller extends BaseInstaller {
         return requirement.type === 'npm';
     }
 
+    supportCheckUpdates(): boolean {
+        return true;
+    }
     /**
      * Check if the NPM package is already installed
      * @param requirement The requirement to check
@@ -70,7 +73,7 @@ export class NpmInstaller extends BaseInstaller {
                 let packageSource: string;
 
                 if (requirement.registry.githubRelease) {
-                    const result = await this.handleGitHubRelease(requirement, requirement.registry.githubRelease);
+                    const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
                     packageSource = result.resolvedPath;
                     resolvedVersion = result.resolvedVersion;
                 } else if (requirement.registry.artifacts) {

package/src/core/installers/{PipInstaller.ts → requirements/PipInstaller.ts}

@@ -1,10 +1,19 @@
-import { RequirementConfig, RequirementStatus } from '../types.js';
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../types.js';
 import { BaseInstaller } from './BaseInstaller.js';
+import { handleGitHubRelease } from '../../../utils/githubUtils.js';
 
 /**
  * Installer implementation for Python packages using pip
  */
 export class PipInstaller extends BaseInstaller {
+    private getPythonCommand(options?: ServerInstallOptions): string {
+        return options?.settings?.pythonEnv as string || 'python';
+    }
+
+    private getPipCommand(options?: ServerInstallOptions): string {
+        const pythonCmd = this.getPythonCommand(options);
+        return `${pythonCmd} -m pip`;
+    }
     /**
      * Check if this installer can handle the given requirement type
      * @param requirement The requirement to check
@@ -14,14 +23,19 @@ export class PipInstaller extends BaseInstaller {
         return requirement.type === 'pip';
     }
 
+    supportCheckUpdates(): boolean {
+        /// temporarily disabling update check for pip as not able to get which pip of python is being used
+        return false;
+    }
     /**
      * Check if the Python package is already installed
      * @param requirement The requirement to check
      * @returns The status of the requirement
      */
-    async checkInstallation(requirement: RequirementConfig): Promise<RequirementStatus> {
+    async checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus> {
         try {
-            const { stdout, stderr } = await this.execPromise(`pip show ${requirement.name}`);
+            const pipCmd = this.getPipCommand(options);
+            const { stdout, stderr } = await this.execPromise(`${pipCmd} show ${requirement.name}`);
 
             // If we get an output and no error, the package is installed
             const installed = stdout.includes(requirement.name);
@@ -51,17 +65,19 @@ export class PipInstaller extends BaseInstaller {
      * @param requirement The requirement to install
      * @returns The status of the installation
      */
-    async install(requirement: RequirementConfig): Promise<RequirementStatus> {
+    async install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus> {
         try {
-            const status = await this.checkInstallation(requirement);
+            const status = await this.checkInstallation(requirement, options);
             if (status.installed) {
                 return status;
             }
 
+            const pipCmd = this.getPipCommand(options);
+
             // If no registry is specified, use standard pip installation
             if (!requirement.registry) {
                 // Standard pip installation
-                const { stderr } = await this.execPromise(`pip install ${requirement.name}==${requirement.version}`);
+                const { stderr } = await this.execPromise(`${pipCmd} install ${requirement.name}==${requirement.version}`);
                 if (stderr && stderr.toLowerCase().includes('error')) {
                     throw new Error(stderr);
                 }
@@ -70,11 +86,11 @@ export class PipInstaller extends BaseInstaller {
                 let packageSource: string;
 
                 if (requirement.registry.githubRelease) {
-                    const result = await this.handleGitHubRelease(requirement, requirement.registry.githubRelease);
+                    const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
                     packageSource = result.resolvedPath;
 
                     // Install from the downloaded wheel or tar.gz file
-                    const { stderr } = await this.execPromise(`pip install "${packageSource}"`);
+                    const { stderr } = await this.execPromise(`${pipCmd} install "${packageSource}"`);
                     if (stderr && stderr.toLowerCase().includes('error')) {
                         throw new Error(stderr);
                     }
@@ -83,7 +99,7 @@ export class PipInstaller extends BaseInstaller {
 
                     // Install using the custom index URL
                     const { stderr } = await this.execPromise(
-                        `pip install ${requirement.name}==${requirement.version} --index-url ${registryUrl}`
+                        `${pipCmd} install ${requirement.name}==${requirement.version} --index-url ${registryUrl}`
                     );
                     if (stderr && stderr.toLowerCase().includes('error')) {
                         throw new Error(stderr);
@@ -92,7 +108,7 @@ export class PipInstaller extends BaseInstaller {
                     packageSource = await this.handleLocalRegistry(requirement, requirement.registry.local);
 
                     // Install from the local path
-                    const { stderr } = await this.execPromise(`pip install "${packageSource}"`);
+                    const { stderr } = await this.execPromise(`${pipCmd} install "${packageSource}"`);
                     if (stderr && stderr.toLowerCase().includes('error')) {
                         throw new Error(stderr);
                     }

package/src/core/installers/requirements/RequirementInstaller.ts

@@ -0,0 +1,41 @@
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../types.js';
+
+/**
+ * Interface for requirement installers.
+ * Implementations should handle specific requirement types.
+ */
+export interface RequirementInstaller {
+    /**
+     * Check if this installer can handle the given requirement type
+     * @param requirement The requirement to check
+     * @returns True if this installer can handle the requirement
+     */
+    canHandle(requirement: RequirementConfig): boolean;
+
+
+    supportCheckUpdates(): boolean;
+
+    /**
+     * Install the requirement
+     * @param requirement The requirement to install
+     * @returns The status of the installation
+     */
+    install(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
+
+    /**
+     * Check if the requirement is already installed
+     * @param requirement The requirement to check
+     * @returns The status of the requirement
+     */
+    checkInstallation(requirement: RequirementConfig, options?: ServerInstallOptions): Promise<RequirementStatus>;
+
+    /**
+     * Check if updates are available for the requirement
+     * @param requirement The requirement to check
+     * @param currentStatus The current status of the requirement
+     * @returns The status of the requirement with update information
+     */
+    checkForUpdates(requirement: RequirementConfig, currentStatus: RequirementStatus): Promise<RequirementStatus>;
+}
+
+// Note: Do not re-export implementations from here to avoid circular dependencies

package/src/core/types.ts

@@ -73,6 +73,8 @@ export interface ServerInstallOptions {
   env?: Record<string, string>; // Environment variables for installation
   targetClients?: string[]; // Target clients for configuration
   requirements?: RequirementConfig[];
+  args?: string[]; // Arguments for installation
+  settings?: Record<string, any>; // Settings for installation like python env
 }
 
 export interface UpdateRequirementOptions {
@@ -101,6 +103,7 @@ export interface DependencyConfig {
   requirements?: Array<{
     name: string;
     version: string;
+    order?: number;
   }>;
   mcpServers?: Array<{
     name: string;
@@ -133,7 +136,7 @@ export interface RegistryConfig {
 
 export interface RequirementConfig {
   name: string;
-  type: 'npm' | 'pip' | 'command' | 'other'; // Add other requirement types if needed
+  type: 'npm' | 'pip' | 'command' | 'extension' | 'other'; // Add other requirement types if needed
   alias?: string; // Alias for the command type
   version: string;
   registry?: RegistryConfig;

package/src/services/ServerService.ts

@@ -88,7 +88,7 @@ export class ServerService {
           }
 
           // Check for updates
-          const updatedStatus = await requirementService.checkRequirementForUpdates(requirement);
+          const updatedStatus = await requirementService.checkRequirementForUpdates(requirement, currentStatus);
 
           // If update information is found, update the configuration
           if (updatedStatus.availableUpdate && serverCategory.name) {

package/src/utils/clientUtils.ts

@@ -84,6 +84,8 @@ export function resolveNpmModulePath(pathString: string): string {
  * @param createIfNotExist Whether to create the file if it doesn't exist
  * @returns The parsed JSON content
  */
+import stripJsonComments from 'strip-json-comments';
+
 export async function readJsonFile(filePath: string, createIfNotExist = false): Promise<any> {
     try {
         // Ensure directory exists
@@ -92,8 +94,8 @@ export async function readJsonFile(filePath: string, createIfNotExist = false):
         }
 
         const content = await fs.readFile(filePath, 'utf8');
-        // Remove trailing commas from JSON content
-        const sanitizedContent = content.replace(/,(\s*[}\]])/g, '$1');
+        // Remove comments and trailing commas from JSON content
+        const sanitizedContent = stripJsonComments(content).replace(/,(\s*[}\]])/g, '$1');
         return JSON.parse(sanitizedContent);
     } catch (error) {
         if ((error as NodeJS.ErrnoException).code === 'ENOENT' && createIfNotExist) {

package/src/utils/githubUtils.ts

@@ -0,0 +1,103 @@
+import { RegistryConfig, RequirementConfig } from '../core/types.js';
+import { exec } from 'child_process';
+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
+ */
+export async function handleGitHubRelease(
+    requirement: RequirementConfig,
+    registry: RegistryConfig['githubRelease']
+): Promise<{ resolvedVersion: string; resolvedPath: string }> {
+    if (!registry) {
+        throw new Error('GitHub release registry configuration 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');
+    }
+
+    let version = requirement.version;
+    let resolvedAssetName = assetName || '';
+    let resolvedAssetsName = assetsName || '';
+
+    const { stdout } = await execAsync(`gh release view --repo ${repository} --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;
+    if (assetsName) {
+        resolvedAssetsName = assetsName.replace('${latest}', version).replace('${version}', version);
+    }
+    if (assetName) {
+        resolvedAssetName = assetName.replace('${latest}', version).replace('${version}', version);
+    }
+
+    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');
+    }
+
+    // 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}"`);
+    }
+
+    // Handle zip file extraction if the downloaded file is a zip
+    if (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);
+            try {
+                await fs.access(assetPath);
+                return { resolvedVersion: version, resolvedPath: 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 { resolvedVersion: version, resolvedPath: downloadPath };
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
+    try {
+        await fs.access(filePath)
+        return true
+    } catch {
+        return false
+    }
+}