imcp 0.0.13 → 0.0.15

package/dist/core/validators/FeedValidator.js

@@ -0,0 +1,80 @@
+import { serverValidatorFactory } from "./ServerValidatorFactory.js";
+import { Logger } from "../../utils/logger.js";
+/**
+ * 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 {
+            Logger.debug(`Validating feed configuration: ${config.name}`);
+            // Validate required fields
+            if (!config.name)
+                throw new Error('Feed name is required');
+            if (!config.displayName)
+                throw new Error('Feed display name is required');
+            if (!config.description)
+                throw new Error('Feed description is required');
+            // Validate MCP servers array
+            if (!Array.isArray(config.mcpServers) || config.mcpServers.length === 0) {
+                throw new Error('Feed must contain at least one MCP server');
+            }
+            // Validate requirements if present
+            if (config.requirements) {
+                for (const req of config.requirements) {
+                    if (!req.name)
+                        throw new Error('Requirement name is required');
+                    if (!req.type)
+                        throw new Error('Requirement type is required');
+                    if (!req.version)
+                        throw new Error('Requirement version is required');
+                }
+            }
+            Logger.debug(`Feed configuration validation successful: ${config.name}`);
+            return true;
+        }
+        catch (error) {
+            const errorMsg = `Feed validation failed: ${error instanceof Error ? error.message : String(error)}`;
+            Logger.error(errorMsg);
+            throw new Error(errorMsg);
+        }
+    }
+    /**
+     * Validates a single MCP server configuration using the appropriate validator
+     * @param server The MCP server configuration to validate
+     * @param config The feed configuration containing shared requirements
+     * @returns true if valid, throws error if invalid
+     */
+    async validateServer(server, config) {
+        try {
+            Logger.debug(`Validating server configuration: ${server.name}`);
+            // Validate basic required fields
+            if (!server.name)
+                throw new Error('Server name is required');
+            if (!server.description)
+                throw new Error('Server description is required');
+            if (!server.mode)
+                throw new Error('Server mode is required');
+            if (!server.installation)
+                throw new Error('Server installation configuration is required');
+            // Get the appropriate validator for this server type
+            const validator = serverValidatorFactory.getValidatorForServer(server);
+            // Perform mode-specific validation with feed config
+            await validator.validateServer(server, config);
+            Logger.debug(`Server configuration validation successful: ${server.name}`);
+            return true;
+        }
+        catch (error) {
+            const errorMsg = `Server validation failed: ${error instanceof Error ? error.message : String(error)}`;
+            Logger.error(errorMsg);
+            throw new Error(errorMsg);
+        }
+    }
+}
+// Export singleton instance
+export const feedValidator = new FeedValidator();
+//# sourceMappingURL=FeedValidator.js.map

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

@@ -0,0 +1,19 @@
+import { McpConfig, FeedConfiguration } from "../types.js";
+/**
+ * Interface for MCP server configuration validators
+ * Defines common validation operations for server configurations
+ */
+export interface IServerValidator {
+    /**
+     * Validates a specific MCP server configuration
+     * Implementation varies based on server mode (stdio/sse)
+     * @param server The MCP server configuration to validate
+     * @param config The feed configuration containing shared requirements
+     * @returns true if valid, throws error if invalid
+     */
+    validateServer(server: McpConfig, config: FeedConfiguration): Promise<boolean>;
+}
+/**
+ * Valid validator types for MCP servers
+ */
+export type ValidatorType = 'stdio' | 'sse';

package/dist/core/validators/IServerValidator.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IServerValidator.js.map

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

@@ -0,0 +1,15 @@
+import { McpConfig, FeedConfiguration } from "../types.js";
+import { IServerValidator } from "./IServerValidator.js";
+/**
+ * Validates MCP server configurations for SSE mode
+ */
+export declare class SSEServerValidator implements IServerValidator {
+    /**
+     * Validates SSE-specific MCP server configuration
+     * Checks installation URL, requirements, and environment variables
+     * @param server The MCP server configuration to validate
+     * @param config The feed configuration containing shared requirements
+     * @returns true if valid, throws error if invalid
+     */
+    validateServer(server: McpConfig, config: FeedConfiguration): Promise<boolean>;
+}

package/dist/core/validators/SSEServerValidator.js

@@ -0,0 +1,39 @@
+import { Logger } from "../../utils/logger.js";
+/**
+ * Validates MCP server configurations for SSE mode
+ */
+export class SSEServerValidator {
+    /**
+     * Validates SSE-specific MCP server configuration
+     * Checks installation URL, requirements, and environment variables
+     * @param server The MCP server configuration to validate
+     * @param config The feed configuration containing shared requirements
+     * @returns true if valid, throws error if invalid
+     */
+    async validateServer(server, config) {
+        try {
+            Logger.debug(`Validating SSE server configuration: ${server.name}`);
+            if (!server.installation?.url) {
+                throw new Error('SSE server URL is required in installation configuration');
+            }
+            try {
+                new URL(server.installation.url);
+            }
+            catch (e) {
+                throw new Error(`Invalid SSE server URL: ${server.installation.url}`);
+            }
+            // Validate server mode
+            if (server.mode !== 'sse') {
+                throw new Error(`Invalid server mode for SSE validator: ${server.mode}`);
+            }
+            // Additional SSE-specific validation will be implemented later
+            return true;
+        }
+        catch (error) {
+            const errorMsg = `Server validation failed: ${error instanceof Error ? error.message : String(error)}`;
+            Logger.error(errorMsg);
+            throw new Error(errorMsg);
+        }
+    }
+}
+//# sourceMappingURL=SSEServerValidator.js.map

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

@@ -0,0 +1,24 @@
+import { McpConfig } from "../types.js";
+import { IServerValidator, ValidatorType } from "./IServerValidator.js";
+/**
+ * Factory class for managing server validator instances
+ * Maintains a singleton map of validators by type
+ */
+export declare class ServerValidatorFactory {
+    private static validators;
+    constructor();
+    /**
+     * Gets the appropriate validator for the given server mode
+     * @param mode The server mode to get validator for
+     * @returns IServerValidator instance for the specified mode
+     * @throws Error if server mode is not supported
+     */
+    getValidator(mode: ValidatorType): IServerValidator;
+    /**
+     * Gets the appropriate validator for the given server config
+     * @param serverConfig MCP server configuration
+     * @returns IServerValidator instance appropriate for the server mode
+     */
+    getValidatorForServer(serverConfig: McpConfig): IServerValidator;
+}
+export declare const serverValidatorFactory: ServerValidatorFactory;

package/dist/core/validators/ServerValidatorFactory.js

@@ -0,0 +1,45 @@
+import { StdioServerValidator } from "./StdioServerValidator.js";
+import { SSEServerValidator } from "./SSEServerValidator.js";
+import { Logger } from "../../utils/logger.js";
+/**
+ * Factory class for managing server validator instances
+ * Maintains a singleton map of validators by type
+ */
+export class ServerValidatorFactory {
+    static validators = new Map();
+    constructor() {
+        // Initialize validators if not already done
+        if (ServerValidatorFactory.validators.size === 0) {
+            Logger.debug('Initializing server validators');
+            ServerValidatorFactory.validators.set('stdio', new StdioServerValidator());
+            ServerValidatorFactory.validators.set('sse', new SSEServerValidator());
+        }
+    }
+    /**
+     * Gets the appropriate validator for the given server mode
+     * @param mode The server mode to get validator for
+     * @returns IServerValidator instance for the specified mode
+     * @throws Error if server mode is not supported
+     */
+    getValidator(mode) {
+        const validator = ServerValidatorFactory.validators.get(mode);
+        if (!validator) {
+            const error = `Unsupported MCP server mode: ${mode}`;
+            Logger.error(error);
+            throw new Error(error);
+        }
+        Logger.debug(`Retrieved ${mode} validator`);
+        return validator;
+    }
+    /**
+     * Gets the appropriate validator for the given server config
+     * @param serverConfig MCP server configuration
+     * @returns IServerValidator instance appropriate for the server mode
+     */
+    getValidatorForServer(serverConfig) {
+        return this.getValidator(serverConfig.mode);
+    }
+}
+// Export singleton instance
+export const serverValidatorFactory = new ServerValidatorFactory();
+//# sourceMappingURL=ServerValidatorFactory.js.map

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

@@ -0,0 +1,46 @@
+import { McpConfig, FeedConfiguration } from "../types.js";
+import { IServerValidator } from "./IServerValidator.js";
+/**
+ * Validates MCP server configurations for stdio mode
+ */
+export declare class StdioServerValidator implements IServerValidator {
+    private installerFactory;
+    /**
+     * Tests if a command exists and is executable
+     * @param command The command to test
+     * @returns true if command exists and is executable
+     */
+    private isCommandExecutable;
+    /**
+     * Generates a dedicated folder path for a requirement.
+     * @param requirement The requirement configuration.
+     * @returns The path to the requirement's dedicated folder.
+     * @private
+     */
+    private _getRequirementFolderPath;
+    /**
+     * Validates and installs a requirement if needed
+     * @param requirement The requirement config to validate and install
+     * @returns true if requirement is successfully installed/validated
+     */
+    private validateRequirement;
+    /**
+     * Tests if a server can be started successfully with proper path resolution
+     * @param command The command to start the server
+     * @param args The command line arguments
+     * @returns Promise<boolean> true if server starts successfully, false otherwise
+     *
+     * Handles special cases:
+     * - For node commands: resolves ${NPMPATH} in arguments using resolveNpmModulePath
+     * - For python/python3 commands: resolves ${PYTHON_PACKAGE} in arguments using system Python packages
+     */
+    private testServerStartup;
+    /**
+     * Validates stdio-specific MCP server configuration
+     * Checks command, arguments, dependencies and required environment variables
+     * @param server The MCP server configuration to validate
+     * @param config The feed configuration containing shared requirements
+     * @returns true if valid, throws error if invalid
+     */
+    validateServer(server: McpConfig, config: FeedConfiguration): Promise<boolean>;
+}

package/dist/core/validators/StdioServerValidator.js

@@ -0,0 +1,229 @@
+import { Logger } from "../../utils/logger.js";
+import { createInstallerFactory } from "../installers/index.js";
+import { exec, spawn } from 'child_process';
+import util from 'util';
+import { MACRO_EXPRESSIONS, resolveNpmModulePath } from "../../utils/macroExpressionUtils.js";
+import { getSystemPythonPackageDirectory } from "../../utils/osUtils.js";
+import { SETTINGS_DIR } from "../constants.js";
+import path from "path";
+const execPromise = util.promisify(exec);
+/**
+ * Validates MCP server configurations for stdio mode
+ */
+export class StdioServerValidator {
+    installerFactory = createInstallerFactory();
+    /**
+     * Tests if a command exists and is executable
+     * @param command The command to test
+     * @returns true if command exists and is executable
+     */
+    async isCommandExecutable(command) {
+        try {
+            Logger.debug(`Testing if command is executable: ${command}`);
+            const testCmd = process.platform === 'win32' ?
+                `where ${command}` :
+                `command -v ${command}`;
+            await execPromise(testCmd);
+            return true;
+        }
+        catch (error) {
+            Logger.debug(`Command not found: ${command}`);
+            return false;
+        }
+    }
+    /**
+     * Generates a dedicated folder path for a requirement.
+     * @param requirement The requirement configuration.
+     * @returns The path to the requirement's dedicated folder.
+     * @private
+     */
+    _getRequirementFolderPath(requirement) {
+        return path.join(SETTINGS_DIR, 'onboard', 'npm_requirements', requirement.name, requirement.version.includes('latest') ? 'latest' : requirement.version);
+    }
+    /**
+     * Validates and installs a requirement if needed
+     * @param requirement The requirement config to validate and install
+     * @returns true if requirement is successfully installed/validated
+     */
+    async validateRequirement(requirement) {
+        try {
+            Logger.debug(`Validating/installing requirement: ${requirement.name}`);
+            const installer = this.installerFactory.getInstaller(requirement);
+            if (!installer) {
+                const msg = `No installer found for requirement type: ${requirement.type}`;
+                Logger.error(msg);
+                throw new Error(msg);
+            }
+            const targetDir = this._getRequirementFolderPath(requirement);
+            const status = await installer.install(requirement, { settings: { folderName: targetDir } });
+            if (!status.installed) {
+                const msg = `Failed to install requirement ${requirement.name}: ${status.error || 'Unknown error'}`;
+                Logger.error(msg);
+                throw new Error(msg);
+            }
+            Logger.debug(`Requirement ${requirement.name} is valid and installed`);
+            return true;
+        }
+        catch (error) {
+            const errorMsg = `Error validating/installing requirement ${requirement.name}: ${error instanceof Error ? error.message : String(error)}`;
+            Logger.error(errorMsg);
+            throw error instanceof Error ? error : new Error(errorMsg);
+        }
+    }
+    /**
+     * Tests if a server can be started successfully with proper path resolution
+     * @param command The command to start the server
+     * @param args The command line arguments
+     * @returns Promise<boolean> true if server starts successfully, false otherwise
+     *
+     * Handles special cases:
+     * - For node commands: resolves ${NPMPATH} in arguments using resolveNpmModulePath
+     * - For python/python3 commands: resolves ${PYTHON_PACKAGE} in arguments using system Python packages
+     */
+    async testServerStartup(command, args, requirement) {
+        try {
+            // Log initial command and args
+            Logger.debug(`Testing server startup with command: ${command}`);
+            Logger.debug(`Original arguments: ${args.join(' ')}`);
+            // Handle path resolution based on command type
+            let finalArgs = [...args];
+            if (command === 'node') {
+                // Resolve npm module paths in arguments
+                Logger.debug('Resolving npm module paths in arguments');
+                const npmPath = requirement ? this._getRequirementFolderPath(requirement) : undefined;
+                finalArgs = args.map(arg => arg.replace(MACRO_EXPRESSIONS.NPMPATH, resolveNpmModulePath(npmPath)));
+                Logger.debug(`Resolved npm arguments: ${finalArgs.join(' ')}`);
+            }
+            else if (command === 'python' || command === 'python3') {
+                // Resolve Python package paths in arguments
+                Logger.debug('Resolving Python package paths in arguments');
+                const pythonDir = await getSystemPythonPackageDirectory();
+                if (pythonDir) {
+                    finalArgs = args.map(arg => arg.includes('${PYTHON_PACKAGE}') ? arg.replace('${PYTHON_PACKAGE}', pythonDir) : arg);
+                    Logger.debug(`Resolved Python arguments: ${finalArgs.join(' ')}`);
+                }
+                else {
+                    const msg = 'Could not resolve system Python package directory';
+                    Logger.error(msg);
+                    throw new Error(msg);
+                }
+            }
+            return await new Promise((resolve, reject) => {
+                Logger.debug(`Starting process with command: ${command} ${finalArgs.join(' ')}`);
+                // Set timeout for server startup test
+                const timeout = setTimeout(() => {
+                    const msg = 'Server startup test timed out after 10 seconds';
+                    Logger.error(msg);
+                    serverProcess.kill();
+                    reject(new Error(msg));
+                }, 20000);
+                // Start the server process
+                const serverProcess = spawn(command, finalArgs, {
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                    shell: true
+                });
+                let output = '';
+                let errorOutput = '';
+                // Collect stdout
+                serverProcess.stdout.on('data', (data) => {
+                    output += data.toString();
+                    // If we see any output, consider it a success
+                    clearTimeout(timeout);
+                    serverProcess.kill();
+                    resolve(true);
+                });
+                // Collect stderr
+                serverProcess.stderr.on('data', (data) => {
+                    errorOutput += data.toString();
+                });
+                // Handle process exit
+                serverProcess.on('exit', (code) => {
+                    clearTimeout(timeout);
+                    if (code !== null && code !== 0) {
+                        const msg = `Server startup failed with code ${code}: ${errorOutput}`;
+                        Logger.error(msg);
+                        reject(new Error(msg));
+                    }
+                });
+                // Handle process error
+                serverProcess.on('error', (error) => {
+                    clearTimeout(timeout);
+                    const msg = `Server startup error: ${error.message}`;
+                    Logger.error(msg);
+                    reject(error);
+                });
+            });
+        }
+        catch (error) {
+            const msg = `Failed to test server startup: ${error instanceof Error ? error.message : String(error)}`;
+            Logger.error(msg);
+            throw error instanceof Error ? error : new Error(msg);
+        }
+    }
+    /**
+     * Validates stdio-specific MCP server configuration
+     * Checks command, arguments, dependencies and required environment variables
+     * @param server The MCP server configuration to validate
+     * @param config The feed configuration containing shared requirements
+     * @returns true if valid, throws error if invalid
+     */
+    async validateServer(server, config) {
+        try {
+            Logger.debug(`Validating stdio server configuration: ${server.name}`);
+            // Check required installation command
+            if (!server.installation?.command) {
+                throw new Error('Server command is required in installation configuration');
+            }
+            // Validate server mode
+            if (server.mode !== 'stdio') {
+                throw new Error(`Invalid server mode for stdio validator: ${server.mode}`);
+            }
+            // Parse command and arguments
+            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) {
+                for (const [name, varConfig] of Object.entries(envVars)) {
+                    if (varConfig.Required && !varConfig.Default && !process.env[name]) {
+                        throw new Error(`Required environment variable not set: ${name}`);
+                    }
+                }
+            }
+            // Validate dependencies if specified
+            if (server.dependencies?.requirements) {
+                Logger.debug(`Validating ${server.dependencies.requirements.length} requirements`);
+                for (const req of server.dependencies.requirements) {
+                    const reqConfig = config.requirements?.find(r => r.name === req.name) || {
+                        name: req.name,
+                        version: req.version,
+                        type: 'npm' // Default to npm if not specified
+                    };
+                    const isValid = await this.validateRequirement(reqConfig);
+                    if (!isValid) {
+                        throw new Error(`Dependency validation failed for: ${req.name}`);
+                    }
+                }
+            }
+            // Test server startup
+            const serverStarted = await this.testServerStartup(baseCommand, args, config.requirements?.find(r => r.type === 'npm'));
+            if (!serverStarted) {
+                throw new Error(`Failed to start server with command: ${fullCommand} ${args.join(' ')}`);
+            }
+            Logger.debug(`Stdio server validation successful: ${server.name}`);
+            return true;
+        }
+        catch (error) {
+            const errorMsg = `Server validation failed: ${error instanceof Error ? error.message : String(error)}`;
+            Logger.error(errorMsg);
+            throw new Error(errorMsg);
+        }
+    }
+}
+//# sourceMappingURL=StdioServerValidator.js.map

package/dist/services/InstallRequestValidator.d.ts

@@ -1,5 +1,5 @@
 import { ServerInstallOptions } from '../core/types.js';
-import { InstallServersRequestBody } from '../web/server.js';
+import { InstallServersRequestBody } from '../web/contract/serverContract.js';
 export declare class InstallRequestValidator {
     private serverFeedConfigs;
     private feedDirectory;

package/dist/services/ServerService.d.ts

@@ -1,5 +1,6 @@
 import { ServerSchema } from '../core/ServerSchemaProvider.js';
-import { MCPServerCategory, ServerInstallOptions, ServerCategoryListOptions, ServerOperationResult, ServerUninstallOptions } from '../core/types.js';
+import { MCPServerCategory, ServerInstallOptions, ServerCategoryListOptions, ServerOperationResult, ServerUninstallOptions, FeedConfiguration } from '../core/types.js';
+import { OperationStatus } from '../core/onboard/OnboardStatus.js';
 /**
  * ServerService provides a unified interface for server management operations.
  * This layer handles business logic that's shared between the CLI and web interface.
@@ -25,13 +26,8 @@ export declare class ServerService {
     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.
      */
     installMcpServer(category: string, serverName: string, options?: ServerInstallOptions): Promise<ServerOperationResult>;
-    /**
-     * Installs a specific mcp tool for a server.
-     * TODO: This might require enhancing MCPManager to handle category-specific installs.
-     */
     /**
      * Uninstall MCP server from specified client targets
      * @param category The server category
@@ -54,5 +50,12 @@ export declare class ServerService {
      * Syncs MCP server configurations from remote feed source
      */
     syncFeeds(): Promise<void>;
+    /**
+     * Onboards a new feed configuration
+     * @param config Feed configuration to onboard
+     */
+    onboardFeed(config: FeedConfiguration): Promise<OperationStatus & {
+        feedConfiguration?: FeedConfiguration;
+    }>;
 }
 export declare const serverService: ServerService;

package/dist/services/ServerService.js

@@ -113,10 +113,8 @@ export class ServerService {
     }
     /**
      * Installs a specific mcp tool for a server.
-     * TODO: This might require enhancing MCPManager to handle category-specific installs.
      */
-    async installMcpServer(category, serverName, options = {} // Reuse ServerInstallOptions for env etc.
-    ) {
+    async installMcpServer(category, serverName, options = {}) {
         Logger.debug(`Installing MCP server: ${JSON.stringify({ category, serverName, options })}`);
         try {
             const result = await mcpManager.installServer(category, serverName, options);
@@ -128,10 +126,6 @@ export class ServerService {
             throw error;
         }
     }
-    /**
-     * Installs a specific mcp tool for a server.
-     * TODO: This might require enhancing MCPManager to handle category-specific installs.
-     */
     /**
      * Uninstall MCP server from specified client targets
      * @param category The server category
@@ -185,6 +179,23 @@ export class ServerService {
     async syncFeeds() {
         return mcpManager.syncFeeds();
     }
+    /**
+     * Onboards a new feed configuration
+     * @param config Feed configuration to onboard
+     */
+    async onboardFeed(config) {
+        try {
+            const result = await mcpManager.onboardFeed(config);
+            // Log based on the operation status, e.g., if it's pending or succeeded.
+            // The actual "success" of onboarding is a multi-step process (PR creation, merge).
+            Logger.log(`Feed onboarding process for '${config.name}' initiated with status: ${result.status}, ID: ${result.onboardingId}`);
+            return result;
+        }
+        catch (error) {
+            Logger.error(`Failed to initiate feed onboarding for '${config.name}':`, error);
+            throw error; // Or return a specific error status object
+        }
+    }
 }
 // Export a singleton instance
 export const serverService = new ServerService();

package/dist/utils/adoUtils.d.ts

@@ -0,0 +1,29 @@
+import { RequirementConfig, RegistryConfig } from '../core/types.js';
+export interface AdoArtifactResult {
+    type: 'npm' | 'pip';
+    package: string;
+    registryUrl: string;
+    folderPath?: string;
+    version: string;
+}
+/**
+ * Handles fetching and setting up an Azure DevOps artifact.
+ * @param requirement The requirement configuration.
+ * @param registry The Azure DevOps artifacts registry configuration.
+ * @param pythonCommand Optional Python command (e.g., 'python', 'python3') for pip operations.
+ * @param targetDir Optional target directory for npm artifact setup. If not provided, a default will be used.
+ * @returns A promise that resolves with the artifact details.
+ */
+export declare function handleArtifact(requirement: RequirementConfig, registry: RegistryConfig['artifacts'], pythonCommand?: string, // Default to 'python' if not provided
+targetDir?: string): Promise<AdoArtifactResult>;
+/**
+ * Get the latest version of an artifact from Azure DevOps.
+ * This is a simplified implementation and might require further enhancements for robust authentication and error handling.
+ * @param execPromise The promise-based exec function.
+ * @param requirement The requirement configuration.
+ * @param registry The Azure DevOps artifacts registry configuration.
+ * @param options Optional server install options (e.g., for pythonCommand).
+ * @returns The latest version string, or undefined if not found or an error occurs.
+ */
+export declare function getArtifactLatestVersion(requirement: RequirementConfig, registry: RegistryConfig['artifacts'], options?: import('../core/types.js').ServerInstallOptions, // Added import for ServerInstallOptions
+targetDir?: string): Promise<string | undefined>;