imcp 0.1.2 → 0.1.4

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

@@ -1,5 +1,6 @@
 import { NpmInstaller } from './NpmInstaller.js';
 import { PipInstaller } from './PipInstaller.js';
+import { NugetInstaller } from './NugetInstaller.js';
 import { CommandInstaller } from './CommandInstaller.js';
 import { GeneralInstaller } from './GeneralInstaller.js';
 import { exec } from 'child_process';
@@ -25,6 +26,7 @@ export class InstallerFactory {
     registerDefaultInstallers() {
         this.registerInstaller(new NpmInstaller(this.execPromise));
         this.registerInstaller(new PipInstaller(this.execPromise));
+        this.registerInstaller(new NugetInstaller(this.execPromise));
         this.registerInstaller(new CommandInstaller(this.execPromise));
         this.registerInstaller(new GeneralInstaller(this.execPromise));
     }

package/dist/core/installers/requirements/NugetInstaller.d.ts

@@ -0,0 +1,37 @@
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
+import { BaseInstaller } from './BaseInstaller.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
+/**
+ * Installer implementation for .NET packages using NuGet
+ */
+export declare class NugetInstaller extends BaseInstaller {
+    /**
+     * 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;
+    /**
+     * Get the latest version available for the NuGet package.
+     * @param requirement The requirement to check.
+     * @param _options Optional server install options (not used for NuGet).
+     * @returns The latest version string, or undefined if not found or not applicable.
+     */
+    getLatestVersion(requirement: RequirementConfig, _options?: ServerInstallOptions): Promise<string | undefined>;
+    /**
+     * Check if the .NET tool is already installed
+     * @param requirement The requirement to check
+     * @param _options Optional server install options (not used for NuGet)
+     * @returns The status of the requirement
+     */
+    checkInstallation(requirement: RequirementConfig, _options?: ServerInstallOptions): Promise<RequirementStatus>;
+    /**
+     * Install the .NET tool
+     * @param requirement The requirement to install
+     * @param recorder Optional InstallOperationManager for recording steps
+     * @param _options Optional server install options (not used for NuGet)
+     * @returns The status of the installation
+     */
+    install(requirement: RequirementConfig, recorder: InstallOperationManager, _options?: ServerInstallOptions): Promise<RequirementStatus>;
+}

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

@@ -0,0 +1,189 @@
+import { BaseInstaller } from './BaseInstaller.js';
+import { handleGitHubRelease, getGitHubLatestVersion } from '../../../utils/githubUtils.js';
+import { compareVersions } from '../../../utils/versionUtils.js';
+import { Logger } from '../../../utils/logger.js';
+import * as RecordingConstants from '../../metadatas/recordingConstants.js';
+import { ensureDotnetToolsInPath } from '../../../utils/osUtils.js';
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * Installer implementation for .NET packages using NuGet
+ */
+export class NugetInstaller extends BaseInstaller {
+    /**
+     * 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) {
+        return requirement.type === 'nuget';
+    }
+    supportCheckUpdates() {
+        return true;
+    }
+    /**
+     * Get the latest version available for the NuGet package.
+     * @param requirement The requirement to check.
+     * @param _options Optional server install options (not used for NuGet).
+     * @returns The latest version string, or undefined if not found or not applicable.
+     */
+    async getLatestVersion(requirement, _options) {
+        if (requirement.registry && requirement.registry.githubRelease) {
+            return getGitHubLatestVersion(this.execPromise, requirement.registry.githubRelease.repository);
+        }
+        // Artifacts registry is not supported for nuget tools
+        if (requirement.registry && requirement.registry.artifacts) {
+            Logger.warn(`Artifacts registry is not supported for NuGet tool '${requirement.name}'.`);
+            return undefined;
+        }
+        // Default behavior: Nuget tools are often specific versions from specific sources,
+        // or global tools might not have a central "latest version" query like pip/npm.
+        // Returning current version if specified, otherwise undefined.
+        Logger.warn(`Direct latest version check for NuGet tool '${requirement.name}' without a GitHub release registry is not supported. Please specify a version or use a GitHub release.`);
+        return requirement.version || undefined;
+    }
+    /**
+     * Check if the .NET tool is already installed
+     * @param requirement The requirement to check
+     * @param _options Optional server install options (not used for NuGet)
+     * @returns The status of the requirement
+     */
+    async checkInstallation(requirement, _options) {
+        try {
+            // Command: dotnet tool list -g
+            // Output:
+            // Package Id       Version      Commands
+            // -----------------------------------------
+            // jarvistools      1.0.0        jarvistools
+            const { stdout } = await this.execPromise(`dotnet tool list -g`);
+            const lines = stdout.split('\n');
+            let installedVersion;
+            let isInstalled = false;
+            for (const line of lines) {
+                const parts = line.trim().split(/\s+/);
+                if (parts.length >= 2 && parts[0].toLowerCase() === requirement.name.toLowerCase()) {
+                    installedVersion = parts[1];
+                    isInstalled = true;
+                    break;
+                }
+            }
+            return {
+                name: requirement.name,
+                type: 'nuget',
+                installed: isInstalled,
+                version: installedVersion,
+                inProgress: false,
+            };
+        }
+        catch (error) {
+            // If 'dotnet tool list -g' fails, it might mean dotnet CLI is not properly installed or configured.
+            // Or it could mean no tools are installed, which in some dotnet versions might return non-zero exit code.
+            // We'll assume not installed in case of error, but log it.
+            Logger.debug(`Error checking NuGet tool installation for ${requirement.name}: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                name: requirement.name,
+                type: 'nuget',
+                installed: false,
+                error: `Failed to check installation: ${error instanceof Error ? error.message : String(error)}`,
+                inProgress: false,
+            };
+        }
+    }
+    /**
+     * Install the .NET tool
+     * @param requirement The requirement to install
+     * @param recorder Optional InstallOperationManager for recording steps
+     * @param _options Optional server install options (not used for NuGet)
+     * @returns The status of the installation
+     */
+    async install(requirement, recorder, _options) {
+        return await recorder.recording(async () => {
+            const status = await this.checkInstallation(requirement, _options);
+            if (status.installed && status.version && requirement.version &&
+                compareVersions(status.version, requirement.version) === 0 &&
+                !requirement.version.toLowerCase().includes('latest')) {
+                Logger.log(`NuGet tool ${requirement.name}==${status.version} already installed.`);
+                return status;
+            }
+            let command;
+            if (requirement.registry && requirement.registry.githubRelease) {
+                const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
+                // Nuget package name might be different from the requirement name if alias is used.
+                // However, dotnet tool install uses the package ID from the nupkg.
+                // We assume requirement.name is the package ID.
+                const packageId = requirement.name;
+                const resolvedDir = fs.existsSync(result.resolvedPath) && fs.lstatSync(result.resolvedPath).isDirectory() ? result.resolvedPath : path.dirname(result.resolvedPath);
+                if (requirement.version && !requirement.version.toLowerCase().includes('latest')) {
+                    command = `dotnet tool install --global --add-source "${resolvedDir}" ${packageId} --version ${requirement.version}`;
+                }
+                else {
+                    // Install latest from the source
+                    command = `dotnet tool install --global --add-source "${resolvedDir}" ${packageId}`;
+                }
+            }
+            else if (requirement.registry && requirement.registry.artifacts) {
+                const errorMessage = `Artifacts registry is not supported for NuGet tool yet'${requirement.name}'. Only GitHubRelease is supported.`;
+                Logger.error(errorMessage);
+                await recorder.recordStep('NugetInstaller:RegistryConfig', 'failed', errorMessage);
+                throw new Error(errorMessage);
+            }
+            else {
+                // Default installation from nuget.org or configured feeds
+                if (requirement.version && !requirement.version.toLowerCase().includes('latest')) {
+                    command = `dotnet tool install --global ${requirement.name} --version ${requirement.version}`;
+                }
+                else {
+                    command = `dotnet tool install --global ${requirement.name}`;
+                }
+            }
+            return await recorder.recording(async () => {
+                const { stdout, stderr } = await this.execPromise(command);
+                if (stderr && !stdout.toLowerCase().includes('already installed')) { // Some warnings might go to stderr
+                    Logger.debug(`NuGet tool installation stderr for ${requirement.name}: ${stderr}`);
+                    // Check if it was actually an error or just a warning
+                    const checkStatus = await this.checkInstallation(requirement, _options);
+                    if (!checkStatus.installed) {
+                        Logger.error(`NuGet tool ${requirement.name} not found after install command, stderr: ${stderr}`);
+                        throw new Error(`NuGet tool installation failed with: ${stderr}`);
+                    }
+                }
+                const finalStatus = await this.checkInstallation(requirement, _options);
+                if (!finalStatus.installed) {
+                    throw new Error(`NuGet tool ${requirement.name} failed to install. Please check logs.`);
+                }
+                // After successful installation, ensure .NET tools path is in system PATH
+                await ensureDotnetToolsInPath();
+                return {
+                    name: requirement.name,
+                    type: 'nuget',
+                    installed: true,
+                    version: finalStatus.version || requirement.version, // Use checked version if available
+                    inProgress: false,
+                };
+            }, {
+                stepName: `${RecordingConstants.STEP_INSTALL_COMMAND_PREFIX}: ${requirement.name} : ${requirement.version || 'latest'}`,
+                inProgressMessage: `Running: ${command}`,
+                endMessage: (result) => result.installed ? `Succeeded: ${command}` : `Failed: ${command}`,
+            });
+        }, {
+            stepName: RecordingConstants.STEP_NUGET_INSTALLER_INSTALL,
+            inProgressMessage: `Installing NuGet tool: ${requirement.name}`,
+            endMessage: (result) => result.installed
+                ? `Install completed for ${requirement.name} with version ${result.version}`
+                : `Install failed for ${requirement.name}`,
+            onError: (error) => {
+                return {
+                    result: {
+                        name: requirement.name,
+                        type: 'nuget',
+                        installed: false,
+                        error: error instanceof Error ? error.message : String(error),
+                        inProgress: false,
+                    },
+                    message: error instanceof Error ? error.message : String(error),
+                };
+            },
+        });
+    }
+}
+//# sourceMappingURL=NugetInstaller.js.map

package/dist/core/metadatas/recordingConstants.d.ts

@@ -12,6 +12,8 @@ export declare const STEP_PROCESS_REQUIREMENT_UPDATES = "Processing all requirem
 export declare const STEP_CHECKING_REQUIREMENT_STATUS = "Checking the status of requirement";
 /** Step for installing requirements in the background process. */
 export declare const STEP_INSTALLING_REQUIREMENTS_IN_BACKGROUND = "Installing requirements in the background";
+/** Step for running the install logic in the NugetInstaller. */
+export declare const STEP_NUGET_INSTALLER_INSTALL = "Running install in NugetInstaller";
 /** Step for checking and installing all requirements as needed. */
 export declare const STEP_CHECK_AND_INSTALL_REQUIREMENTS = "Checking and installing all requirements";
 /** Step for running the install logic in the CommandInstaller. */

package/dist/core/metadatas/recordingConstants.js

@@ -12,6 +12,8 @@ export const STEP_PROCESS_REQUIREMENT_UPDATES = 'Processing all requirement upda
 export const STEP_CHECKING_REQUIREMENT_STATUS = 'Checking the status of requirement';
 /** Step for installing requirements in the background process. */
 export const STEP_INSTALLING_REQUIREMENTS_IN_BACKGROUND = 'Installing requirements in the background';
+/** Step for running the install logic in the NugetInstaller. */
+export const STEP_NUGET_INSTALLER_INSTALL = 'Running install in NugetInstaller';
 /** Step for checking and installing all requirements as needed. */
 export const STEP_CHECK_AND_INSTALL_REQUIREMENTS = 'Checking and installing all requirements';
 /** Step for running the install logic in the CommandInstaller. */

package/dist/core/metadatas/types.d.ts

@@ -121,7 +121,7 @@ export interface RegistryConfig {
 }
 export interface RequirementConfig {
     name: string;
-    type: 'npm' | 'pip' | 'command' | 'extension' | 'other';
+    type: 'npm' | 'pip' | 'command' | 'extension' | 'nuget' | 'other';
     alias?: string;
     version: string;
     registry?: RegistryConfig;

package/dist/core/onboard/FeedOnboardService.js

@@ -91,28 +91,7 @@ export class FeedOnboardService {
      * @returns A promise that resolves to the operation status.
      */
     async _initiateOperation(config, operationType, serverList, forExistingCategory) {
-        // First, check for existing non-completed operations
-        let existingOperation = await onboardStatusManager._findExistingNonCompletedOperation(config.name, operationType);
-        if (existingOperation) {
-            const fiveMinutesInMs = 5 * 60 * 1000;
-            const lastUpdateTimestamp = existingOperation.lastUpdated ? new Date(existingOperation.lastUpdated).getTime() : 0;
-            const currentTime = new Date().getTime();
-            if (lastUpdateTimestamp > 0 && (currentTime - lastUpdateTimestamp) > fiveMinutesInMs) {
-                Logger.log(`WARNING: [${existingOperation.onboardingId}] Found stale ${operationType} operation for feed: ${config.name} (last updated at: ${existingOperation.lastUpdated}). Proceeding to create a new operation.`);
-                existingOperation = undefined; // Treat as no existing operation for starting a new one
-            }
-            else {
-                Logger.log(`[${existingOperation.onboardingId}] Found existing non-completed ${operationType} operation for feed: ${config.name}. Returning its status.`);
-                const lastStep = existingOperation.steps && existingOperation.steps.length > 0 ? existingOperation.steps[existingOperation.steps.length - 1].stepName : 'N/A';
-                return {
-                    onboardingId: existingOperation.onboardingId,
-                    status: existingOperation.status,
-                    message: `An ${operationType} process for this feed (${existingOperation.onboardingId}) is already in status: ${existingOperation.status}. Last step: ${lastStep}`,
-                    lastQueried: new Date().toISOString(),
-                };
-            }
-        }
-        // Then, check for successful operations with matching configuration
+        // Check for successful operations with matching configuration
         const succeededOperation = await onboardStatusManager.findSucceededOperation(config.name, operationType, config);
         if (succeededOperation) {
             Logger.log(`[${succeededOperation.onboardingId}] Found existing successful ${operationType} operation for feed: ${config.name} with matching configuration.`);

package/dist/core/validators/StdioServerValidator.js

@@ -235,11 +235,6 @@ export class StdioServerValidator {
             const fullCommand = server.installation.command;
             const [baseCommand, ...defaultArgs] = fullCommand.split(' ');
             const args = [...defaultArgs, ...(server.installation.args || [])];
-            // Validate command exists and is executable
-            const isExecutable = await this.isCommandExecutable(baseCommand);
-            if (!isExecutable) {
-                throw new Error(`Command not found or not executable: ${baseCommand}`);
-            }
             // Validate required environment variables if specified
             const envVars = server.installation.env;
             if (envVars) {
@@ -264,6 +259,11 @@ export class StdioServerValidator {
                     }
                 }
             }
+            // Validate command exists and is executable
+            const isExecutable = await this.isCommandExecutable(baseCommand);
+            if (!isExecutable) {
+                throw new Error(`Command not found or not executable: ${baseCommand}`);
+            }
             // Test server startup
             const serverStarted = await this.testServerStartup(baseCommand, args, config.requirements?.find(r => r.type === 'npm'));
             if (!serverStarted) {

package/dist/utils/osUtils.d.ts

@@ -36,3 +36,14 @@ export declare function getGlobalNPMPackagePath(): string;
  * Returns the directory containing the npm executable, or a platform-appropriate default if not found.
  */
 export declare function getNpmExecutablePath(): Promise<string>;
+/**
+ * Ensures the .NET global tools path is added to the system PATH for the current user
+ * on macOS and Linux by modifying shell configuration files.
+ * This function is idempotent and will not add the path if it already exists.
+ */
+export declare function ensureDotnetToolsInPath(): Promise<void>;
+/**
+ *
+ * @returns The path to the .dotnet global tools directory.
+ */
+export declare function getDotnetGlobalToolsPath(): string;

package/dist/utils/osUtils.js

@@ -562,4 +562,104 @@ export async function getNpmExecutablePath() {
         }
     }
 }
+/**
+ * Ensures the .NET global tools path is added to the system PATH for the current user
+ * on macOS and Linux by modifying shell configuration files.
+ * This function is idempotent and will not add the path if it already exists.
+ */
+export async function ensureDotnetToolsInPath() {
+    const osType = getOSType();
+    Logger.debug({
+        action: 'ensure_dotnet_tools_in_path',
+        osType
+    });
+    if (osType === OSType.Windows) {
+        Logger.debug('.NET tools PATH is usually handled by the installer on Windows. Skipping explicit PATH modification.');
+        return;
+    }
+    if (osType === OSType.MacOS || osType === OSType.Linux) {
+        const dotnetToolsPath = getDotnetGlobalToolsPath(); // This is typically ~/.dotnet/tools
+        const exportLine = `export PATH="${dotnetToolsPath}:$PATH"`;
+        // Determine shell configuration files to check/update
+        const shellConfigFiles = [];
+        const shell = process.env.SHELL;
+        if (shell && shell.includes('zsh')) {
+            shellConfigFiles.push(path.join(os.homedir(), '.zshrc'));
+        }
+        else if (shell && shell.includes('bash')) {
+            shellConfigFiles.push(path.join(os.homedir(), '.bashrc'));
+            // .bash_profile is often sourced by .bashrc or used for login shells
+            shellConfigFiles.push(path.join(os.homedir(), '.bash_profile'));
+        }
+        else {
+            // Fallback for other shells or if SHELL is not set
+            shellConfigFiles.push(path.join(os.homedir(), '.profile'));
+            shellConfigFiles.push(path.join(os.homedir(), '.bashrc'));
+            shellConfigFiles.push(path.join(os.homedir(), '.zshrc'));
+        }
+        let updatedAnyFile = false;
+        for (const configFile of shellConfigFiles) {
+            try {
+                if (fs.existsSync(configFile)) {
+                    const content = await fs.promises.readFile(configFile, 'utf-8');
+                    // Check if the exact line or a line setting dotnetToolsPath in PATH exists
+                    // A more robust check might involve parsing, but this covers common cases.
+                    // Regex to check if dotnetToolsPath is part of an PATH export, avoiding duplicates.
+                    // It looks for `export PATH=...$dotnetToolsPath...` or `export PATH=...${HOME}/.dotnet/tools...`
+                    const pathRegex = new RegExp(`export\\s+PATH=.*${dotnetToolsPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}.*`);
+                    const homePathRegex = new RegExp(`export\\s+PATH=.*\\$HOME\\/\\.dotnet\\/tools.*`);
+                    if (!pathRegex.test(content) && !homePathRegex.test(content)) {
+                        Logger.debug(`Adding .NET tools path to ${configFile}`);
+                        await fs.promises.appendFile(configFile, `\n# Add .NET Core SDK tools to PATH\n${exportLine}\n`);
+                        Logger.log(`Appended '${exportLine}' to ${configFile}. You may need to source this file or restart your terminal.`);
+                        updatedAnyFile = true;
+                    }
+                    else {
+                        Logger.debug(`.NET tools path already configured in ${configFile}`);
+                    }
+                }
+                else if (shellConfigFiles.length === 1 || configFile === path.join(os.homedir(), '.profile')) {
+                    // If it's the only config file determined or it's .profile, and it doesn't exist, create it.
+                    Logger.debug(`${configFile} does not exist. Creating and adding .NET tools path.`);
+                    await fs.promises.writeFile(configFile, `# Add .NET Core SDK tools to PATH\n${exportLine}\n`);
+                    Logger.log(`Created ${configFile} and added '${exportLine}'. You may need to source this file or restart your terminal.`);
+                    updatedAnyFile = true;
+                }
+            }
+            catch (error) {
+                Logger.error(`Failed to update ${configFile} for .NET tools PATH: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (updatedAnyFile) {
+            Logger.log(`Dotnet tools path has been added to shell configuration. Please source the relevant file (e.g., 'source ~/.zshrc') or restart your terminal session for changes to take effect.`);
+        }
+        // Also update the current process's PATH environment variable
+        if (process.env.PATH && !process.env.PATH.includes(dotnetToolsPath)) {
+            process.env.PATH = `${dotnetToolsPath}:${process.env.PATH}`;
+            Logger.debug(`Updated current process.env.PATH to include: ${dotnetToolsPath}`);
+        }
+        else if (!process.env.PATH) {
+            process.env.PATH = dotnetToolsPath;
+            Logger.debug(`Set current process.env.PATH to: ${dotnetToolsPath}`);
+        }
+    }
+}
+/**
+ *
+ * @returns The path to the .dotnet global tools directory.
+ */
+export function getDotnetGlobalToolsPath() {
+    const homeDir = os.homedir();
+    if (process.platform === 'win32') {
+        // Example: C:\Users\YourName\.dotnet\tools
+        return path.join(homeDir, '.dotnet', 'tools');
+    }
+    else if (process.platform === 'darwin' || process.platform === 'linux') {
+        // macOS or Linux: ~/.dotnet/tools
+        return path.join(homeDir, '.dotnet', 'tools');
+    }
+    else {
+        throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+}
 //# sourceMappingURL=osUtils.js.map

package/dist/web/public/js/onboard/templates.js

@@ -235,6 +235,7 @@ export const serverRequirementTemplate = (serverIndex, reqIndex, isReadOnly = fa
           <option value="">Select Type</option>
           <option value="npm">NPM Package</option>
           <option value="pip">PIP Package</option>
+          <option value="nuget">Nuget Package</option>
           <option value="command">Command</option>
         </select>
       </div>

package/dist/web/public/js/serverCategoryList.js

@@ -158,16 +158,16 @@ function renderServerCategoryList(servers) {
 
         return `
         <div class="server-item border border-gray-200 p-3 rounded hover:bg-gray-50 cursor-pointer transition duration-150 ease-in-out ${pinnedClass}"
-             data-server-name="${server.name}">
+             data-server-name="${server.name}" onclick="navigateToCategory('${server.name}')">
             <div class="flex justify-between items-center">
-                <h3 class="font-semibold text-gray-800" onclick="navigateToCategory('${server.name}')">${server.displayName || server.name}</h3>
+                <h3 class="font-semibold text-gray-800">${server.displayName || server.name}</h3>
                 <div class="flex items-center">
                     <div class="pin-button ${pinnedClass}" onclick="togglePinCategoryItem('${server.name}', event)" title="${isPinned ? 'Unpin' : 'Pin'} this category">
                         ${pinIcon}
                     </div>
                 </div>
             </div>
-            <div class="text-sm text-gray-500 flex items-center mt-1" onclick="navigateToCategory('${server.name}')">
+            <div class="text-sm text-gray-500 flex items-center mt-1">
                 ${statusHtml}
                 ${systemTagsHtml}
             </div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imcp",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Node.js SDK for Model Context Protocol (MCP)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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

@@ -2,6 +2,7 @@ import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../.
 import { RequirementInstaller } from './RequirementInstaller.js';
 import { NpmInstaller } from './NpmInstaller.js';
 import { PipInstaller } from './PipInstaller.js';
+import { NugetInstaller } from './NugetInstaller.js';
 import { CommandInstaller } from './CommandInstaller.js';
 import { GeneralInstaller } from './GeneralInstaller.js';
 import { exec } from 'child_process';
@@ -30,6 +31,7 @@ export class InstallerFactory {
     private registerDefaultInstallers(): void {
         this.registerInstaller(new NpmInstaller(this.execPromise));
         this.registerInstaller(new PipInstaller(this.execPromise));
+        this.registerInstaller(new NugetInstaller(this.execPromise));
         this.registerInstaller(new CommandInstaller(this.execPromise));
         this.registerInstaller(new GeneralInstaller(this.execPromise));
     }

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

@@ -0,0 +1,203 @@
+import { RequirementConfig, RequirementStatus, ServerInstallOptions } from '../../metadatas/types.js';
+import { BaseInstaller } from './BaseInstaller.js';
+import { handleGitHubRelease, getGitHubLatestVersion } from '../../../utils/githubUtils.js';
+import { compareVersions } from '../../../utils/versionUtils.js';
+import { Logger } from '../../../utils/logger.js';
+import { InstallOperationManager } from '../../loaders/InstallOperationManager.js';
+import * as RecordingConstants from '../../metadatas/recordingConstants.js';
+import { ensureDotnetToolsInPath } from '../../../utils/osUtils.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Installer implementation for .NET packages using NuGet
+ */
+export class NugetInstaller extends BaseInstaller {
+    /**
+     * 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 {
+        return requirement.type === 'nuget';
+    }
+
+    supportCheckUpdates(): boolean {
+        return true;
+    }
+
+    /**
+     * Get the latest version available for the NuGet package.
+     * @param requirement The requirement to check.
+     * @param _options Optional server install options (not used for NuGet).
+     * @returns The latest version string, or undefined if not found or not applicable.
+     */
+    async getLatestVersion(requirement: RequirementConfig, _options?: ServerInstallOptions): Promise<string | undefined> {
+        if (requirement.registry && requirement.registry.githubRelease) {
+            return getGitHubLatestVersion(this.execPromise, requirement.registry.githubRelease.repository);
+        }
+        // Artifacts registry is not supported for nuget tools
+        if (requirement.registry && requirement.registry.artifacts) {
+            Logger.warn(`Artifacts registry is not supported for NuGet tool '${requirement.name}'.`);
+            return undefined;
+        }
+        // Default behavior: Nuget tools are often specific versions from specific sources,
+        // or global tools might not have a central "latest version" query like pip/npm.
+        // Returning current version if specified, otherwise undefined.
+        Logger.warn(`Direct latest version check for NuGet tool '${requirement.name}' without a GitHub release registry is not supported. Please specify a version or use a GitHub release.`);
+        return requirement.version || undefined;
+    }
+
+    /**
+     * Check if the .NET tool is already installed
+     * @param requirement The requirement to check
+     * @param _options Optional server install options (not used for NuGet)
+     * @returns The status of the requirement
+     */
+    async checkInstallation(requirement: RequirementConfig, _options?: ServerInstallOptions): Promise<RequirementStatus> {
+        try {
+            // Command: dotnet tool list -g
+            // Output:
+            // Package Id       Version      Commands
+            // -----------------------------------------
+            // jarvistools      1.0.0        jarvistools
+            const { stdout } = await this.execPromise(`dotnet tool list -g`);
+            const lines = stdout.split('\n');
+            let installedVersion: string | undefined;
+            let isInstalled = false;
+
+            for (const line of lines) {
+                const parts = line.trim().split(/\s+/);
+                if (parts.length >= 2 && parts[0].toLowerCase() === requirement.name.toLowerCase()) {
+                    installedVersion = parts[1];
+                    isInstalled = true;
+                    break;
+                }
+            }
+
+            return {
+                name: requirement.name,
+                type: 'nuget',
+                installed: isInstalled,
+                version: installedVersion,
+                inProgress: false,
+            };
+        } catch (error) {
+            // If 'dotnet tool list -g' fails, it might mean dotnet CLI is not properly installed or configured.
+            // Or it could mean no tools are installed, which in some dotnet versions might return non-zero exit code.
+            // We'll assume not installed in case of error, but log it.
+            Logger.debug(`Error checking NuGet tool installation for ${requirement.name}: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                name: requirement.name,
+                type: 'nuget',
+                installed: false,
+                error: `Failed to check installation: ${error instanceof Error ? error.message : String(error)}`,
+                inProgress: false,
+            };
+        }
+    }
+
+    /**
+     * Install the .NET tool
+     * @param requirement The requirement to install
+     * @param recorder Optional InstallOperationManager for recording steps
+     * @param _options Optional server install options (not used for NuGet)
+     * @returns The status of the installation
+     */
+    async install(requirement: RequirementConfig, recorder: InstallOperationManager, _options?: ServerInstallOptions): Promise<RequirementStatus> {
+        return await recorder.recording(
+            async (): Promise<RequirementStatus> => {
+                const status = await this.checkInstallation(requirement, _options);
+                if (status.installed && status.version && requirement.version &&
+                    compareVersions(status.version, requirement.version) === 0 &&
+                    !requirement.version.toLowerCase().includes('latest')) {
+                    Logger.log(`NuGet tool ${requirement.name}==${status.version} already installed.`);
+                    return status;
+                }
+
+                let command: string;
+
+                if (requirement.registry && requirement.registry.githubRelease) {
+                    const result = await handleGitHubRelease(requirement, requirement.registry.githubRelease);
+                    // Nuget package name might be different from the requirement name if alias is used.
+                    // However, dotnet tool install uses the package ID from the nupkg.
+                    // We assume requirement.name is the package ID.
+                    const packageId = requirement.name;
+                    const resolvedDir = fs.existsSync(result.resolvedPath) && fs.lstatSync(result.resolvedPath).isDirectory() ? result.resolvedPath : path.dirname(result.resolvedPath);
+
+                    if (requirement.version && !requirement.version.toLowerCase().includes('latest')) {
+                        command = `dotnet tool install --global --add-source "${resolvedDir}" ${packageId} --version ${requirement.version}`;
+                    } else {
+                        // Install latest from the source
+                        command = `dotnet tool install --global --add-source "${resolvedDir}" ${packageId}`;
+                    }
+                } else if (requirement.registry && requirement.registry.artifacts) {
+                    const errorMessage = `Artifacts registry is not supported for NuGet tool yet'${requirement.name}'. Only GitHubRelease is supported.`;
+                    Logger.error(errorMessage);
+                    await recorder.recordStep('NugetInstaller:RegistryConfig', 'failed', errorMessage);
+                    throw new Error(errorMessage);
+                } else {
+                    // Default installation from nuget.org or configured feeds
+                    if (requirement.version && !requirement.version.toLowerCase().includes('latest')) {
+                        command = `dotnet tool install --global ${requirement.name} --version ${requirement.version}`;
+                    } else {
+                        command = `dotnet tool install --global ${requirement.name}`;
+                    }
+                }
+
+                return await recorder.recording(
+                    async () => {
+                        const { stdout, stderr } = await this.execPromise(command);
+                        if (stderr && !stdout.toLowerCase().includes('already installed')) { // Some warnings might go to stderr
+                            Logger.debug(`NuGet tool installation stderr for ${requirement.name}: ${stderr}`);
+                            // Check if it was actually an error or just a warning
+                            const checkStatus = await this.checkInstallation(requirement, _options);
+                            if (!checkStatus.installed) {
+                                Logger.error(`NuGet tool ${requirement.name} not found after install command, stderr: ${stderr}`);
+                                throw new Error(`NuGet tool installation failed with: ${stderr}`);
+                            }
+                        }
+
+                        const finalStatus = await this.checkInstallation(requirement, _options);
+                        if (!finalStatus.installed) {
+                             throw new Error(`NuGet tool ${requirement.name} failed to install. Please check logs.`);
+                        }
+                        // After successful installation, ensure .NET tools path is in system PATH
+                        await ensureDotnetToolsInPath();
+                        return {
+                            name: requirement.name,
+                            type: 'nuget',
+                            installed: true,
+                            version: finalStatus.version || requirement.version, // Use checked version if available
+                            inProgress: false,
+                        };
+                    },
+                    {
+                        stepName: `${RecordingConstants.STEP_INSTALL_COMMAND_PREFIX}: ${requirement.name} : ${requirement.version || 'latest'}`,
+                        inProgressMessage: `Running: ${command}`,
+                        endMessage: (result) => result.installed ? `Succeeded: ${command}` : `Failed: ${command}`,
+                    }
+                );
+            },
+            {
+                stepName: RecordingConstants.STEP_NUGET_INSTALLER_INSTALL,
+                inProgressMessage: `Installing NuGet tool: ${requirement.name}`,
+                endMessage: (result) => result.installed
+                    ? `Install completed for ${requirement.name} with version ${result.version}`
+                    : `Install failed for ${requirement.name}`,
+                onError: (error) => {
+                    return {
+                        result: {
+                            name: requirement.name,
+                            type: 'nuget',
+                            installed: false,
+                            error: error instanceof Error ? error.message : String(error),
+                            inProgress: false,
+                        },
+                        message: error instanceof Error ? error.message : String(error),
+                    };
+                },
+            }
+        );
+    }
+}

package/src/core/metadatas/recordingConstants.ts

@@ -16,6 +16,9 @@ export const STEP_CHECKING_REQUIREMENT_STATUS = 'Checking the status of requirem
 /** Step for installing requirements in the background process. */
 export const STEP_INSTALLING_REQUIREMENTS_IN_BACKGROUND = 'Installing requirements in the background';
 
+/** Step for running the install logic in the NugetInstaller. */
+export const STEP_NUGET_INSTALLER_INSTALL = 'Running install in NugetInstaller';
+
 /** Step for checking and installing all requirements as needed. */
 export const STEP_CHECK_AND_INSTALL_REQUIREMENTS = 'Checking and installing all requirements';
 

package/src/core/metadatas/types.ts

@@ -139,7 +139,7 @@ export interface RegistryConfig {
 
 export interface RequirementConfig {
   name: string;
-  type: 'npm' | 'pip' | 'command' | 'extension' | 'other'; // Add other requirement types if needed
+  type: 'npm' | 'pip' | 'command' | 'extension' | 'nuget' | 'other'; // Add other requirement types if needed
   alias?: string; // Alias for the command type
   version: string;
   registry?: RegistryConfig;

package/src/core/onboard/FeedOnboardService.ts

@@ -106,30 +106,7 @@ export class FeedOnboardService {
    * @returns A promise that resolves to the operation status.
    */
   private async _initiateOperation(config: FeedConfiguration, operationType: OperationType, serverList: string[], forExistingCategory?: boolean): Promise<OperationStatus & { feedConfiguration?: FeedConfiguration }> {
-    // First, check for existing non-completed operations
-    let existingOperation = await onboardStatusManager._findExistingNonCompletedOperation(config.name, operationType);
-
-    if (existingOperation) {
-      const fiveMinutesInMs = 5 * 60 * 1000;
-      const lastUpdateTimestamp = existingOperation.lastUpdated ? new Date(existingOperation.lastUpdated).getTime() : 0;
-      const currentTime = new Date().getTime();
-
-      if (lastUpdateTimestamp > 0 && (currentTime - lastUpdateTimestamp) > fiveMinutesInMs) {
-        Logger.log(`WARNING: [${existingOperation.onboardingId}] Found stale ${operationType} operation for feed: ${config.name} (last updated at: ${existingOperation.lastUpdated}). Proceeding to create a new operation.`);
-        existingOperation = undefined; // Treat as no existing operation for starting a new one
-      } else {
-        Logger.log(`[${existingOperation.onboardingId}] Found existing non-completed ${operationType} operation for feed: ${config.name}. Returning its status.`);
-        const lastStep = existingOperation.steps && existingOperation.steps.length > 0 ? existingOperation.steps[existingOperation.steps.length - 1].stepName : 'N/A';
-        return {
-          onboardingId: existingOperation.onboardingId,
-          status: existingOperation.status,
-          message: `An ${operationType} process for this feed (${existingOperation.onboardingId}) is already in status: ${existingOperation.status}. Last step: ${lastStep}`,
-          lastQueried: new Date().toISOString(),
-        };
-      }
-    }
-
-    // Then, check for successful operations with matching configuration
+    // Check for successful operations with matching configuration
     const succeededOperation = await onboardStatusManager.findSucceededOperation(config.name, operationType, config);
     if (succeededOperation) {
       Logger.log(`[${succeededOperation.onboardingId}] Found existing successful ${operationType} operation for feed: ${config.name} with matching configuration.`);

package/src/core/validators/StdioServerValidator.ts

@@ -262,11 +262,6 @@ export class StdioServerValidator implements IServerValidator {
       const [baseCommand, ...defaultArgs] = fullCommand.split(' ');
       const args = [...defaultArgs, ...(server.installation.args || [])];
 
-      // Validate command exists and is executable
-      const isExecutable = await this.isCommandExecutable(baseCommand);
-      if (!isExecutable) {
-        throw new Error(`Command not found or not executable: ${baseCommand}`);
-      }
 
       // Validate required environment variables if specified
       const envVars = server.installation.env;
@@ -295,6 +290,12 @@ export class StdioServerValidator implements IServerValidator {
           }
         }
       }
+            // Validate command exists and is executable
+      const isExecutable = await this.isCommandExecutable(baseCommand);
+      if (!isExecutable) {
+        throw new Error(`Command not found or not executable: ${baseCommand}`);
+      }
+
       // Test server startup
       const serverStarted = await this.testServerStartup(baseCommand, args, config.requirements?.find(r => r.type === 'npm'));
       if (!serverStarted) {

package/src/utils/osUtils.ts

@@ -594,4 +594,107 @@ export async function getNpmExecutablePath(): Promise<string> {
       return '/usr/local/bin';
     }
   }
-}
+}
+
+/**
+ * Ensures the .NET global tools path is added to the system PATH for the current user
+ * on macOS and Linux by modifying shell configuration files.
+ * This function is idempotent and will not add the path if it already exists.
+ */
+export async function ensureDotnetToolsInPath(): Promise<void> {
+  const osType = getOSType();
+  Logger.debug({
+    action: 'ensure_dotnet_tools_in_path',
+    osType
+  });
+
+  if (osType === OSType.Windows) {
+    Logger.debug('.NET tools PATH is usually handled by the installer on Windows. Skipping explicit PATH modification.');
+    return;
+  }
+
+  if (osType === OSType.MacOS || osType === OSType.Linux) {
+    const dotnetToolsPath = getDotnetGlobalToolsPath(); // This is typically ~/.dotnet/tools
+    const exportLine = `export PATH="${dotnetToolsPath}:$PATH"`;
+
+    // Determine shell configuration files to check/update
+    const shellConfigFiles: string[] = [];
+    const shell = process.env.SHELL;
+
+    if (shell && shell.includes('zsh')) {
+      shellConfigFiles.push(path.join(os.homedir(), '.zshrc'));
+    } else if (shell && shell.includes('bash')) {
+      shellConfigFiles.push(path.join(os.homedir(), '.bashrc'));
+      // .bash_profile is often sourced by .bashrc or used for login shells
+      shellConfigFiles.push(path.join(os.homedir(), '.bash_profile'));
+    } else {
+      // Fallback for other shells or if SHELL is not set
+      shellConfigFiles.push(path.join(os.homedir(), '.profile'));
+      shellConfigFiles.push(path.join(os.homedir(), '.bashrc'));
+      shellConfigFiles.push(path.join(os.homedir(), '.zshrc'));
+    }
+    
+    let updatedAnyFile = false;
+
+    for (const configFile of shellConfigFiles) {
+      try {
+        if (fs.existsSync(configFile)) {
+          const content = await fs.promises.readFile(configFile, 'utf-8');
+          // Check if the exact line or a line setting dotnetToolsPath in PATH exists
+          // A more robust check might involve parsing, but this covers common cases.
+          // Regex to check if dotnetToolsPath is part of an PATH export, avoiding duplicates.
+          // It looks for `export PATH=...$dotnetToolsPath...` or `export PATH=...${HOME}/.dotnet/tools...`
+          const pathRegex = new RegExp(`export\\s+PATH=.*${dotnetToolsPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}.*`);
+          const homePathRegex = new RegExp(`export\\s+PATH=.*\\$HOME\\/\\.dotnet\\/tools.*`);
+
+          if (!pathRegex.test(content) && !homePathRegex.test(content)) {
+            Logger.debug(`Adding .NET tools path to ${configFile}`);
+            await fs.promises.appendFile(configFile, `\n# Add .NET Core SDK tools to PATH\n${exportLine}\n`);
+            Logger.log(`Appended '${exportLine}' to ${configFile}. You may need to source this file or restart your terminal.`);
+            updatedAnyFile = true;
+          } else {
+            Logger.debug(`.NET tools path already configured in ${configFile}`);
+          }
+        } else if (shellConfigFiles.length === 1 || configFile === path.join(os.homedir(), '.profile')) {
+          // If it's the only config file determined or it's .profile, and it doesn't exist, create it.
+          Logger.debug(`${configFile} does not exist. Creating and adding .NET tools path.`);
+          await fs.promises.writeFile(configFile, `# Add .NET Core SDK tools to PATH\n${exportLine}\n`);
+          Logger.log(`Created ${configFile} and added '${exportLine}'. You may need to source this file or restart your terminal.`);
+          updatedAnyFile = true;
+        }
+      } catch (error) {
+        Logger.error(`Failed to update ${configFile} for .NET tools PATH: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    if (updatedAnyFile) {
+        Logger.log(`Dotnet tools path has been added to shell configuration. Please source the relevant file (e.g., 'source ~/.zshrc') or restart your terminal session for changes to take effect.`);
+    }
+
+    // Also update the current process's PATH environment variable
+    if (process.env.PATH && !process.env.PATH.includes(dotnetToolsPath)) {
+      process.env.PATH = `${dotnetToolsPath}:${process.env.PATH}`;
+      Logger.debug(`Updated current process.env.PATH to include: ${dotnetToolsPath}`);
+    } else if (!process.env.PATH) {
+      process.env.PATH = dotnetToolsPath;
+      Logger.debug(`Set current process.env.PATH to: ${dotnetToolsPath}`);
+    }
+  }
+}
+/**
+ * 
+ * @returns The path to the .dotnet global tools directory.
+ */
+export function getDotnetGlobalToolsPath(): string {
+  const homeDir = os.homedir();
+
+  if (process.platform === 'win32') {
+    // Example: C:\Users\YourName\.dotnet\tools
+    return path.join(homeDir, '.dotnet', 'tools');
+  } else if (process.platform === 'darwin' || process.platform === 'linux') {
+    // macOS or Linux: ~/.dotnet/tools
+    return path.join(homeDir, '.dotnet', 'tools');
+  } else {
+    throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+}
+

package/src/web/public/js/onboard/templates.js

@@ -235,6 +235,7 @@ export const serverRequirementTemplate = (serverIndex, reqIndex, isReadOnly = fa
           <option value="">Select Type</option>
           <option value="npm">NPM Package</option>
           <option value="pip">PIP Package</option>
+          <option value="nuget">Nuget Package</option>
           <option value="command">Command</option>
         </select>
       </div>

package/src/web/public/js/serverCategoryList.js

@@ -158,16 +158,16 @@ function renderServerCategoryList(servers) {
 
         return `
         <div class="server-item border border-gray-200 p-3 rounded hover:bg-gray-50 cursor-pointer transition duration-150 ease-in-out ${pinnedClass}"
-             data-server-name="${server.name}">
+             data-server-name="${server.name}" onclick="navigateToCategory('${server.name}')">
             <div class="flex justify-between items-center">
-                <h3 class="font-semibold text-gray-800" onclick="navigateToCategory('${server.name}')">${server.displayName || server.name}</h3>
+                <h3 class="font-semibold text-gray-800">${server.displayName || server.name}</h3>
                 <div class="flex items-center">
                     <div class="pin-button ${pinnedClass}" onclick="togglePinCategoryItem('${server.name}', event)" title="${isPinned ? 'Unpin' : 'Pin'} this category">
                         ${pinIcon}
                     </div>
                 </div>
             </div>
-            <div class="text-sm text-gray-500 flex items-center mt-1" onclick="navigateToCategory('${server.name}')">
+            <div class="text-sm text-gray-500 flex items-center mt-1">
                 ${statusHtml}
                 ${systemTagsHtml}
             </div>