imcp 0.0.16 → 0.0.17

package/{src/core/ServerSchemaProvider.ts → dist/core/loaders/ServerSchemaProvider.js}

@@ -1,137 +1,120 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { LOCAL_FEEDS_SCHEMA_DIR } from './constants.js';
-import { Logger } from '../utils/logger.js';
-
-export interface ServerSchema {
-    schema: Record<string, any>;
-}
-
-export class ServerSchemaProvider {
-    private static instance: ServerSchemaProvider;
-    private schemaMap: Map<string, Map<string, ServerSchema>>;
-    private schemaLock: Promise<void> = Promise.resolve();
-
-    private constructor() {
-        this.schemaMap = new Map();
-    }
-
-    public static async getInstance(): Promise<ServerSchemaProvider> {
-        if (!ServerSchemaProvider.instance) {
-            ServerSchemaProvider.instance = new ServerSchemaProvider();
-            await ServerSchemaProvider.instance.initialize();
-        }
-        return ServerSchemaProvider.instance;
-    }
-
-    private async withLock<T>(operation: () => Promise<T>): Promise<T> {
-        const current = this.schemaLock;
-        let resolve: () => void;
-        this.schemaLock = new Promise<void>(r => resolve = r);
-        try {
-            await current;
-            return await operation();
-        } finally {
-            resolve!();
-        }
-    }
-
-    async initialize(): Promise<void> {
-        await this.withLock(async () => {
-            try {
-                // Create feeds directory if it doesn't exist
-                await fs.mkdir(LOCAL_FEEDS_SCHEMA_DIR, { recursive: true });
-
-                // Load all schemas from the feeds directory
-                await this.loadAllSchemas();
-            } catch (error) {
-                Logger.error('Error during schema initialization:', error);
-                throw error;
-            }
-        });
-    }
-
-    private async loadSchema(categoryName: string, schemaFileName: string): Promise<ServerSchema | undefined> {
-        try {
-            const schemaPath = path.join(LOCAL_FEEDS_SCHEMA_DIR, categoryName, schemaFileName);
-            const content = await fs.readFile(schemaPath, 'utf8');
-            const schema = JSON.parse(content);
-
-            return {
-                schema: schema
-            };
-        } catch (error) {
-            if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-                Logger.debug(`No schema file found for ${schemaFileName} in category ${categoryName}`);
-                return undefined;
-            }
-            Logger.error(`Error loading schema ${schemaFileName} in category ${categoryName}:`, error);
-            throw error;
-        }
-    }
-
-    private async loadAllSchemas(): Promise<void> {
-        this.schemaMap.clear();
-
-        // Read server category directories
-        const categoryDirs = await fs.readdir(LOCAL_FEEDS_SCHEMA_DIR, { withFileTypes: true });
-
-        for (const categoryDir of categoryDirs) {
-            if (categoryDir.isDirectory()) {
-                const categoryPath = path.join(LOCAL_FEEDS_SCHEMA_DIR, categoryDir.name);
-                const serverFiles = await fs.readdir(categoryPath);
-
-                const serverSchemas = new Map<string, ServerSchema>();
-
-                for (const file of serverFiles) {
-                    if (file.endsWith('.json')) {
-                        try {
-                            const schema = await this.loadSchema(categoryDir.name, file);
-                            if (schema) {
-                                // Store with the complete file name for direct lookup
-                                serverSchemas.set(file, schema);
-                            }
-                        } catch (error) {
-                            Logger.error(`Error loading schema for file ${file} in category ${categoryDir.name}:`, error);
-                        }
-                    }
-                }
-
-                if (serverSchemas.size > 0) {
-                    this.schemaMap.set(categoryDir.name, serverSchemas);
-                }
-            }
-        }
-    }
-
-    async getSchema(categoryName: string, schemaFileName: string): Promise<ServerSchema | undefined> {
-        return await this.withLock(async () => {
-            const categorySchemas = this.schemaMap.get(categoryName);
-            if (!categorySchemas) {
-                Logger.debug(`No schemas found for category ${categoryName}`);
-                return undefined;
-            }
-            const schema = categorySchemas.get(schemaFileName);
-            if (!schema) {
-                Logger.debug(`Schema ${schemaFileName} not found in category ${categoryName}`);
-            }
-            return schema;
-        });
-    }
-
-    async reloadSchemas(): Promise<void> {
-        return await this.withLock(async () => {
-            await this.loadAllSchemas();
-        });
-    }
-}
-
-// Export a lazy initialized singleton instance getter
-let initPromise: Promise<ServerSchemaProvider> | null = null;
-
-export function getServerSchemaProvider(): Promise<ServerSchemaProvider> {
-    if (!initPromise) {
-        initPromise = ServerSchemaProvider.getInstance();
-    }
-    return initPromise;
-}
+import fs from 'fs/promises';
+import path from 'path';
+import { LOCAL_FEEDS_SCHEMA_DIR } from '../metadatas/constants.js';
+import { Logger } from '../../utils/logger.js';
+export class ServerSchemaProvider {
+    static instance;
+    schemaMap;
+    schemaLock = Promise.resolve();
+    constructor() {
+        this.schemaMap = new Map();
+    }
+    static async getInstance() {
+        if (!ServerSchemaProvider.instance) {
+            ServerSchemaProvider.instance = new ServerSchemaProvider();
+            await ServerSchemaProvider.instance.initialize();
+        }
+        return ServerSchemaProvider.instance;
+    }
+    async withLock(operation) {
+        const current = this.schemaLock;
+        let resolve;
+        this.schemaLock = new Promise(r => resolve = r);
+        try {
+            await current;
+            return await operation();
+        }
+        finally {
+            resolve();
+        }
+    }
+    async initialize() {
+        await this.withLock(async () => {
+            try {
+                // Create feeds directory if it doesn't exist
+                await fs.mkdir(LOCAL_FEEDS_SCHEMA_DIR, { recursive: true });
+                // Load all schemas from the feeds directory
+                await this.loadAllSchemas();
+            }
+            catch (error) {
+                Logger.error('Error during schema initialization:', error);
+                throw error;
+            }
+        });
+    }
+    async loadSchema(categoryName, schemaFileName) {
+        try {
+            const schemaPath = path.join(LOCAL_FEEDS_SCHEMA_DIR, categoryName, schemaFileName);
+            const content = await fs.readFile(schemaPath, 'utf8');
+            const schema = JSON.parse(content);
+            return {
+                schema: schema
+            };
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                Logger.debug(`No schema file found for ${schemaFileName} in category ${categoryName}`);
+                return undefined;
+            }
+            Logger.error(`Error loading schema ${schemaFileName} in category ${categoryName}:`, error);
+            throw error;
+        }
+    }
+    async loadAllSchemas() {
+        this.schemaMap.clear();
+        // Read server category directories
+        const categoryDirs = await fs.readdir(LOCAL_FEEDS_SCHEMA_DIR, { withFileTypes: true });
+        for (const categoryDir of categoryDirs) {
+            if (categoryDir.isDirectory()) {
+                const categoryPath = path.join(LOCAL_FEEDS_SCHEMA_DIR, categoryDir.name);
+                const serverFiles = await fs.readdir(categoryPath);
+                const serverSchemas = new Map();
+                for (const file of serverFiles) {
+                    if (file.endsWith('.json')) {
+                        try {
+                            const schema = await this.loadSchema(categoryDir.name, file);
+                            if (schema) {
+                                // Store with the complete file name for direct lookup
+                                serverSchemas.set(file, schema);
+                            }
+                        }
+                        catch (error) {
+                            Logger.error(`Error loading schema for file ${file} in category ${categoryDir.name}:`, error);
+                        }
+                    }
+                }
+                if (serverSchemas.size > 0) {
+                    this.schemaMap.set(categoryDir.name, serverSchemas);
+                }
+            }
+        }
+    }
+    async getSchema(categoryName, schemaFileName) {
+        return await this.withLock(async () => {
+            const categorySchemas = this.schemaMap.get(categoryName);
+            if (!categorySchemas) {
+                Logger.debug(`No schemas found for category ${categoryName}`);
+                return undefined;
+            }
+            const schema = categorySchemas.get(schemaFileName);
+            if (!schema) {
+                Logger.debug(`Schema ${schemaFileName} not found in category ${categoryName}`);
+            }
+            return schema;
+        });
+    }
+    async reloadSchemas() {
+        return await this.withLock(async () => {
+            await this.loadAllSchemas();
+        });
+    }
+}
+// Export a lazy initialized singleton instance getter
+let initPromise = null;
+export function getServerSchemaProvider() {
+    if (!initPromise) {
+        initPromise = ServerSchemaProvider.getInstance();
+    }
+    return initPromise;
+}
+//# sourceMappingURL=ServerSchemaProvider.js.map

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

@@ -0,0 +1,47 @@
+/**
+ * Defines constants used across the application.
+ */
+/**
+ * GitHub repository configuration for feeds
+ */
+export declare const GITHUB_REPO: {
+    url: string;
+    repoName: string;
+    feedsPath: string;
+    feedAssetsName: string;
+};
+/**
+ * Local settings directory path based on OS
+ */
+export declare const SETTINGS_DIR: string;
+/**
+ * Local feeds directory path
+ */
+export declare const LOCAL_FEEDS_DIR: string;
+export declare const LOCAL_FEEDS_SCHEMA_DIR: string;
+/**
+ * Supported client configurations.
+ * Key: Client name (e.g., 'vscode')
+ * Value: Client-specific settings or configuration details.
+ * TODO: Define actual client settings structure.
+ */
+export declare const SUPPORTED_CLIENTS: Record<string, {
+    extension: {
+        extensionId: string;
+        leastVersion?: string;
+        repository?: string;
+        assetName?: string;
+        private?: boolean;
+    };
+    codeSettingPath: string;
+    codeInsiderSettingPath: string;
+}>;
+/**
+ * List of supported client names.
+ */
+export declare const SUPPORTED_CLIENT_NAMES: string[];
+/**
+ * Minimum time between requirement update checks (in milliseconds)
+ * 10 minutes = 10 * 60 * 1000 = 600000 ms
+ */
+export declare const UPDATE_CHECK_INTERVAL_MS: number;

package/dist/core/metadatas/constants.js

@@ -0,0 +1,94 @@
+import os from 'os';
+import path from 'path';
+/**
+ * Defines constants used across the application.
+ */
+/**
+ * GitHub repository configuration for feeds
+ */
+export const GITHUB_REPO = {
+    url: 'https://github.com/ai-microsoft/imcp-feed.git',
+    repoName: 'ai-microsoft/imcp-feed',
+    feedsPath: 'feeds',
+    feedAssetsName: 'imcp-feeds-${latest}.zip',
+};
+/**
+ * Local settings directory path based on OS
+ */
+export const SETTINGS_DIR = (() => {
+    switch (process.platform) {
+        case 'win32':
+            return path.join(os.homedir(), '.imcp');
+        default: // linux, darwin (macOS), etc.
+            return path.join(os.homedir(), '.imcp');
+    }
+})();
+/**
+ * Local feeds directory path
+ */
+export const LOCAL_FEEDS_DIR = path.join(SETTINGS_DIR, 'feeds');
+export const LOCAL_FEEDS_SCHEMA_DIR = path.join(LOCAL_FEEDS_DIR, 'schemas');
+const CODE_STRORAGE_DIR = (() => {
+    switch (process.platform) {
+        case 'win32':
+            return path.join(os.homedir(), 'AppData', 'Roaming', 'Code', 'User');
+        case 'darwin': // macOS
+            return path.join(os.homedir(), 'Library', 'Application Support', 'Code', 'User');
+        default: // linux
+            return path.join(os.homedir(), '.config', 'Code', 'User');
+    }
+})();
+const CODE_INSIDER_STRORAGE_DIR = (() => {
+    switch (process.platform) {
+        case 'win32':
+            return path.join(os.homedir(), 'AppData', 'Roaming', 'Code - Insiders', 'User');
+        case 'darwin': // macOS
+            return path.join(os.homedir(), 'Library', 'Application Support', 'Code - Insiders', 'User');
+        default: // linux
+            return path.join(os.homedir(), '.config', 'Code - Insiders', 'User');
+    }
+})();
+/**
+ * Supported client configurations.
+ * Key: Client name (e.g., 'vscode')
+ * Value: Client-specific settings or configuration details.
+ * TODO: Define actual client settings structure.
+ */
+export const SUPPORTED_CLIENTS = {
+    'MSRooCode': {
+        extension: {
+            extensionId: 'microsoftai.ms-roo-cline',
+            leastVersion: '0.0.8',
+            repository: 'ai-microsoft/roo-cline',
+            assetName: 'ms-roo-cline-${version}.vsix',
+            private: true
+        },
+        codeSettingPath: path.join(CODE_STRORAGE_DIR, 'globalStorage', 'microsoftai.ms-roo-cline', 'settings', 'cline_mcp_settings.json'),
+        codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'globalStorage', 'microsoftai.ms-roo-cline', 'settings', 'cline_mcp_settings.json'),
+    },
+    'Cline': {
+        extension: {
+            extensionId: 'saoudrizwan.claude-dev',
+        },
+        codeSettingPath: path.join(CODE_STRORAGE_DIR, 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
+        codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
+    },
+    'GithubCopilot': {
+        extension: {
+            extensionId: 'github.copilot',
+        },
+        codeSettingPath: path.join(CODE_STRORAGE_DIR, 'settings.json'),
+        codeInsiderSettingPath: path.join(CODE_INSIDER_STRORAGE_DIR, 'settings.json'),
+    },
+    // Add other supported clients here
+};
+/**
+ * List of supported client names.
+ */
+export const SUPPORTED_CLIENT_NAMES = Object.keys(SUPPORTED_CLIENTS);
+/**
+ * Minimum time between requirement update checks (in milliseconds)
+ * 10 minutes = 10 * 60 * 1000 = 600000 ms
+ */
+export const UPDATE_CHECK_INTERVAL_MS = 10 * 60 * 1000; // 10 minutes
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1,166 @@
+export declare enum OSType {
+    Windows = "windows",
+    MacOS = "macos",
+    Linux = "linux"
+}
+export interface RequirementStatus {
+    name: string;
+    type: string;
+    installed: boolean;
+    inProgress?: boolean;
+    version?: string;
+    error?: string;
+    availableUpdate?: {
+        version: string;
+        message: string;
+    };
+    lastCheckTime?: string;
+    operationStatus?: OperationStatus;
+    pythonEnv?: string;
+    npmPath?: string;
+}
+export interface MCPServerStatus {
+    installedStatus: Record<string, OperationStatus>;
+    name: string;
+    tags?: string[];
+    error?: string;
+}
+export interface OperationStatus {
+    status: 'pending' | 'in-progress' | 'completed' | 'failed';
+    type: 'install' | 'uninstall' | 'update' | 'check';
+    target: 'requirement' | 'server';
+    message?: string;
+    error?: string;
+    operationId?: string;
+}
+export interface InstallationStatus {
+    requirementsStatus: Record<string, RequirementStatus>;
+    serversStatus: Record<string, MCPServerStatus>;
+    lastUpdated: string;
+}
+export interface MCPServerCategory {
+    name: string;
+    displayName: string;
+    description?: string;
+    type: 'local';
+    tags?: string[];
+    path?: string;
+    installationStatus?: InstallationStatus;
+    feedConfiguration?: FeedConfiguration;
+}
+export interface ServerCategoryListOptions {
+    local?: boolean;
+}
+export interface ServerOperationResult {
+    success: boolean;
+    message?: string;
+    error?: Error;
+    output?: string;
+    status?: OperationStatus[];
+}
+export interface MCPConfiguration {
+    localServerCategories: MCPServerCategory[];
+    feeds: Record<string, FeedConfiguration>;
+    clientMCPSettings?: Record<string, Record<string, any>>;
+}
+export interface ServerInstallOptions {
+    force?: boolean;
+    env?: Record<string, string>;
+    targetClients?: string[];
+    requirements?: RequirementConfig[];
+    args?: string[];
+    settings?: Record<string, any>;
+}
+export interface UpdateRequirementOptions {
+    requirementName: string;
+    updateVersion: string;
+}
+export interface ServerUninstallOptions {
+    removeData?: boolean;
+    targets?: string[];
+}
+export interface EnvVariableConfig {
+    Required: boolean;
+    Description: string;
+    Default?: string;
+}
+export interface InstallationConfig {
+    command: string;
+    args: string[];
+    env?: Record<string, EnvVariableConfig>;
+    url?: string;
+}
+export interface DependencyConfig {
+    requirements?: Array<{
+        name: string;
+        version: string;
+        order?: number;
+    }>;
+    mcpServers?: Array<{
+        name: string;
+    }>;
+}
+export interface McpConfig {
+    name: string;
+    description: string;
+    mode: 'stdio' | 'sse';
+    dependencies?: DependencyConfig;
+    schemas?: string;
+    repository?: string;
+    installation: InstallationConfig;
+}
+export interface RegistryConfig {
+    githubRelease?: {
+        repository: string;
+        assetsName?: string;
+        assetName: string;
+    };
+    artifacts?: {
+        registryUrl: string;
+        registryName: string;
+    };
+}
+export interface RequirementConfig {
+    name: string;
+    type: 'npm' | 'pip' | 'command' | 'extension' | 'other';
+    alias?: string;
+    version: string;
+    registry?: RegistryConfig;
+}
+export interface FeedConfiguration {
+    name: string;
+    displayName: string;
+    description: string;
+    repository?: string;
+    requirements: RequirementConfig[];
+    mcpServers: McpConfig[];
+}
+export interface ClientSettings {
+    codeSettingPath: string;
+    codeInsiderSettingPath: string;
+}
+export declare enum MCPEvent {
+    SERVER_INSTALLED = "server:installed",
+    SERVER_UNINSTALLED = "server:uninstalled",
+    SERVER_STARTED = "server:started",
+    SERVER_STOPPED = "server:stopped",
+    CONFIG_CHANGED = "config:changed"
+}
+export interface MCPEventData {
+    [MCPEvent.SERVER_INSTALLED]: {
+        server: MCPServerCategory;
+    };
+    [MCPEvent.SERVER_UNINSTALLED]: {
+        serverName: string;
+        targets?: string[];
+    };
+    [MCPEvent.SERVER_STARTED]: {
+        server: MCPServerCategory;
+    };
+    [MCPEvent.SERVER_STOPPED]: {
+        serverName: string;
+    };
+    [MCPEvent.CONFIG_CHANGED]: {
+        configuration: MCPConfiguration;
+    };
+}

package/dist/core/metadatas/types.js

@@ -0,0 +1,16 @@
+export var OSType;
+(function (OSType) {
+    OSType["Windows"] = "windows";
+    OSType["MacOS"] = "macos";
+    OSType["Linux"] = "linux";
+})(OSType || (OSType = {}));
+// Events that can be emitted by the SDK
+export var MCPEvent;
+(function (MCPEvent) {
+    MCPEvent["SERVER_INSTALLED"] = "server:installed";
+    MCPEvent["SERVER_UNINSTALLED"] = "server:uninstalled";
+    MCPEvent["SERVER_STARTED"] = "server:started";
+    MCPEvent["SERVER_STOPPED"] = "server:stopped";
+    MCPEvent["CONFIG_CHANGED"] = "config:changed";
+})(MCPEvent || (MCPEvent = {}));
+//# sourceMappingURL=types.js.map

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

@@ -1,4 +1,4 @@
-import { FeedConfiguration } from '../types.js';
+import { FeedConfiguration } from '../metadatas/types.js';
 import { OperationStatus } from './OnboardStatus.js';
 /**
  * Service for handling feed onboarding operations

package/dist/core/onboard/FeedOnboardService.js

@@ -1,4 +1,4 @@
-import { configProvider } from '../ConfigurationProvider.js';
+import { configProvider } from '../loaders/ConfigurationProvider.js';
 import { feedValidator } from '../validators/FeedValidator.js';
 import { Logger } from '../../utils/logger.js';
 import { OnboardingProcessStatus } from './OnboardStatus.js';

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

@@ -1,4 +1,4 @@
-import { FeedConfiguration } from '../types.js';
+import { FeedConfiguration } from '../metadatas/types.js';
 /**
  * Class responsible for handling GitHub operations during the onboarding process
  */

package/dist/core/onboard/OnboardProcessor.js

@@ -2,7 +2,7 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 import fs from 'fs/promises';
 import path from 'path';
-import { GITHUB_REPO, SETTINGS_DIR } from '../constants.js';
+import { GITHUB_REPO, SETTINGS_DIR } from '../metadatas/constants.js';
 import { Logger } from '../../utils/logger.js';
 const execAsync = promisify(exec);
 /**

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

@@ -1,4 +1,4 @@
-import { FeedConfiguration } from "../types.js";
+import { FeedConfiguration } from "../metadatas/types.js";
 export declare enum OnboardingProcessStatus {
     VALIDATING = "validating",
     VALIDATED = "validated",

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

@@ -1,4 +1,4 @@
-import { FeedConfiguration } from '../types.js';
+import { FeedConfiguration } from '../metadatas/types.js';
 import { OnboardStatus, OperationType } from './OnboardStatus.js';
 export declare class OnboardStatusManager {
     private static instance;

package/dist/core/onboard/OnboardStatusManager.js

@@ -1,6 +1,6 @@
 import fs from 'fs/promises';
 import path from 'path';
-import { SETTINGS_DIR } from '../constants.js';
+import { SETTINGS_DIR } from '../metadatas/constants.js';
 import { OnboardingProcessStatus } from './OnboardStatus.js';
 import { Logger } from '../../utils/logger.js';
 const ONBOARD_STATUS_DIR = path.join(SETTINGS_DIR, 'onboard');

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

@@ -1,4 +1,4 @@
-import { FeedConfiguration, McpConfig } from "../types.js";
+import { FeedConfiguration, McpConfig } from "../metadatas/types.js";
 /**
  * Validates feed configurations to ensure they meet required criteria
  */

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

@@ -1,4 +1,4 @@
-import { McpConfig, FeedConfiguration } from "../types.js";
+import { McpConfig, FeedConfiguration } from "../metadatas/types.js";
 /**
  * Interface for MCP server configuration validators
  * Defines common validation operations for server configurations

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

@@ -1,4 +1,4 @@
-import { McpConfig, FeedConfiguration } from "../types.js";
+import { McpConfig, FeedConfiguration } from "../metadatas/types.js";
 import { IServerValidator } from "./IServerValidator.js";
 /**
  * Validates MCP server configurations for SSE mode