imcp 0.0.12 → 0.0.13

package/src/core/constants.ts

@@ -10,7 +10,9 @@ import path from 'path';
  */
 export const GITHUB_REPO = {
   url: 'https://github.com/ai-microsoft/imcp-feed.git',
-  feedsPath: 'feeds'
+  repoName: 'ai-microsoft/imcp-feed',
+  feedsPath: 'feeds',
+  feedAssetsName: 'imcp-feeds-${latest}.zip',
 };
 
 /**
@@ -29,6 +31,7 @@ export const SETTINGS_DIR = (() => {
  * 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) {

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

@@ -25,7 +25,7 @@ export class PipInstaller extends BaseInstaller {
 
     supportCheckUpdates(): boolean {
         /// temporarily disabling update check for pip as not able to get which pip of python is being used
-        return false;
+        return true;
     }
     /**
      * Check if the Python package is already installed
@@ -47,7 +47,8 @@ export class PipInstaller extends BaseInstaller {
                 type: 'pip',
                 installed,
                 version: installedVersion,
-                inProgress: false
+                inProgress: false,
+                pythonEnv: this.getPythonCommand(options) // Preserve pythonEnv in status check too
             };
         } catch (error) {
             return {
@@ -55,7 +56,8 @@ export class PipInstaller extends BaseInstaller {
                 type: 'pip',
                 installed: false,
                 error: error instanceof Error ? error.message : String(error),
-                inProgress: false
+                inProgress: false,
+                pythonEnv: this.getPythonCommand(options) // Preserve pythonEnv even in error case
             };
         }
     }
@@ -117,12 +119,14 @@ export class PipInstaller extends BaseInstaller {
                 }
             }
 
+            // Store the pythonEnv in the status for future use
             return {
                 name: requirement.name,
                 type: 'pip',
                 installed: true,
                 version: requirement.version,
-                inProgress: false
+                inProgress: false,
+                pythonEnv: this.getPythonCommand(options) // Store the python env
             };
         } catch (error) {
             return {
@@ -130,7 +134,8 @@ export class PipInstaller extends BaseInstaller {
                 type: 'pip',
                 installed: false,
                 error: error instanceof Error ? error.message : String(error),
-                inProgress: false
+                inProgress: false,
+                pythonEnv: this.getPythonCommand(options) // Store the python env
             };
         }
     }

package/src/core/types.ts

@@ -17,6 +17,7 @@ export interface RequirementStatus {
   };
   lastCheckTime?: string;
   operationStatus?: OperationStatus;
+  pythonEnv?: string; // Store Python environment path for pip requirements
 }
 
 export interface MCPServerStatus {
@@ -116,6 +117,8 @@ export interface McpConfig {
   description: string;
   mode: 'stdio' | 'http'; // Currently only stdio mode is supported in ai-coder-tools
   dependencies?: DependencyConfig;
+  schemas?: string; // Path to the schema file
+  repository?: string; // Repository URL for the server
   installation: InstallationConfig;
 }
 
@@ -147,6 +150,7 @@ export interface FeedConfiguration {
   name: string;
   displayName: string;
   description: string;
+  repository?: string;
   requirements: RequirementConfig[];
   mcpServers: McpConfig[];
 }

package/src/services/ServerService.ts

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

package/src/utils/githubAuth.ts

@@ -9,7 +9,7 @@ const execAsync = util.promisify(exec);
 const spawnAsync = (command: string, args: string[], options: any = {}) => {
   return new Promise((resolve, reject) => {
     const childProcess = spawn(command, args, options);
-    
+
     childProcess.on('close', (code) => {
       if (code === 0) {
         resolve(code);
@@ -17,7 +17,7 @@ const spawnAsync = (command: string, args: string[], options: any = {}) => {
         reject(new Error(`Process exited with code ${code}`));
       }
     });
-    
+
     childProcess.on('error', (err) => {
       reject(err);
     });
@@ -35,29 +35,16 @@ export async function checkGithubAuth(): Promise<void> {
   Logger.debug('Starting GitHub authentication check');
 
   try {
-    // Check if git is installed
-    if (!await isToolInstalled('git')) {
-      Logger.log('Installing required Git...');
-      await installCLI('git');
-      
-      // Verify git was installed correctly, with retry mechanism
-      if (!await isToolInstalled('git')) {
-        throw new Error('Failed to install Git. Please install it manually and try again.');
-      }
-      
-      Logger.debug('Git installed successfully and verified');
-    }
-
     // Check if gh CLI is installed
     if (!await isToolInstalled('gh')) {
       Logger.log('Installing required GitHub CLI...');
       await installCLI('gh');
-      
+
       // Verify gh CLI was installed correctly, with retry mechanism
       if (!await isToolInstalled('gh')) {
         throw new Error('Failed to install GitHub CLI. Please install it manually and try again.');
       }
-      
+
       Logger.debug('GitHub CLI installed successfully and verified');
     }
   } catch (error) {
@@ -70,12 +57,12 @@ export async function checkGithubAuth(): Promise<void> {
     // Check if user is authenticated
     const { stdout: viewerData } = await execAsync('gh api user');
     const viewer = JSON.parse(viewerData);
-    
+
     Logger.debug({
       action: 'github_auth_check',
       username: viewer.login
     });
-    
+
     // Check if user is using company account (ends with _microsoft)
     if (!viewer.login.toLowerCase().endsWith('_microsoft')) {
       const error = 'Error: You must be logged in with a Microsoft account (username should end with _microsoft). ' +
@@ -92,34 +79,34 @@ export async function checkGithubAuth(): Promise<void> {
     if (error instanceof GithubAuthError) {
       throw error;
     }
-    
+
     // If the error is due to not being authenticated
     const errorMessage = (error as any)?.stderr || (error as Error).message;
     if (errorMessage.includes('please run:  gh auth login') || errorMessage.includes('GH_TOKEN')) {
       Logger.log('GitHub authentication required at the first run. Please login account end with _microsoft.');
-      
+
       try {
         // Use spawnAsync for interactive authentication
         await spawnAsync('gh', ['auth', 'login', '--web', '--hostname', 'github.com', '--git-protocol', 'https'], {
           stdio: 'inherit' // User sees & interacts directly with the process
         });
-        
+
         Logger.debug('GitHub authentication process completed');
-        
+
         // Verify the authentication was successful
         const { stdout: viewerData } = await execAsync('gh api user');
         const viewer = JSON.parse(viewerData);
-        
+
         // Check if user is using company account (ends with _microsoft)
         if (!viewer.login.toLowerCase().endsWith('_microsoft')) {
           throw new GithubAuthError('You must be logged in with a Microsoft account (username should end with _microsoft).');
         }
-        
+
         Logger.debug(`Successfully authenticated as ${viewer.login}`);
         return; // Auth successful, continue execution
       } catch (loginError) {
         Logger.error('Error during GitHub authentication process', loginError);
-        
+
         // If the interactive login failed, provide manual instructions
         const authInstructions =
           '\nError: GitHub authentication required. Please follow these steps:\n\n' +
@@ -129,7 +116,7 @@ export async function checkGithubAuth(): Promise<void> {
           '3. Follow the prompts to login with your Microsoft account (username must end with _microsoft)\n' +
           '4. Authorize ai-microsoft organization.\n' +
           '5. After successful login, run imcp command again.\n\n';
-        
+
         Logger.log(authInstructions);
         throw new GithubAuthError('GitHub authentication required. Please login first and try again.');
       }

package/src/utils/githubUtils.ts

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

package/src/web/public/css/detailsWidget.css

@@ -0,0 +1,235 @@
+.details-widget {
+    transition: all 0.3s ease-in-out;
+    width: 100%;
+    max-width: 100%;
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+    display: block;
+    overflow: hidden;
+}
+
+.tools-list {
+    width: 100%;
+    max-width: 100%;
+    margin: 0;
+    padding: 0.1rem;
+    box-sizing: border-box;
+    overflow: hidden;
+}
+
+.tool-card {
+    width: 100%;
+    margin-bottom: -1px;
+    border-radius: 0;
+    box-sizing: border-box;
+}
+
+.tool-card:first-child {
+    border-top-left-radius: 6px;
+    border-top-right-radius: 6px;
+}
+
+.tool-card:last-child {
+    border-bottom-left-radius: 6px;
+    border-bottom-right-radius: 6px;
+    margin-bottom: 0;
+}
+
+.tool-card {
+    transition: all 0.3s ease-out;
+    border: 1px solid #e5e7eb;
+    padding: 0.5rem;
+    background-color: white;
+    position: relative;
+    z-index: 1;
+    font-size: 0.9rem;
+    width: 100%;
+    box-sizing: border-box;
+}
+
+.tool-card .text-gray-600 {
+    font-size: 0.75rem;
+    line-height: 1.3;
+}
+
+.tool-card.active {
+    box-shadow: 0 4px 15px rgba(0, 0, 0, 0.12);
+    border-color: transparent;
+    background-color: #f8fafc;
+}
+
+.tool-card:hover {
+    transform: translateY(-1px);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.08);
+}
+
+.tool-card-header {
+    position: relative;
+    padding-right: 2rem;
+    width: 100%;
+    box-sizing: border-box;
+    cursor: pointer;
+}
+
+.tool-card-header::after {
+    content: '';
+    position: absolute;
+    right: 1rem;
+    top: 50%;
+    transform: translateY(-50%);
+    width: 12px;
+    height: 12px;
+    border-right: 2px solid #64748b;
+    border-bottom: 2px solid #64748b;
+    transform-origin: 75% 75%;
+    transition: transform 0.3s ease;
+}
+
+.tool-card.active .tool-card-header::after {
+    transform: translateY(-50%) rotate(45deg);
+}
+
+.tool-details {
+    max-height: 0;
+    opacity: 0;
+    overflow: hidden;
+    transition: all 0.4s cubic-bezier(0.4, 0, 0.2, 1);
+    background-color: #f9fafb;
+    border-radius: 6px;
+    width: 100%;
+    max-width: 100%;
+    box-sizing: border-box;
+}
+
+.tool-details.visible {
+    max-height: 2000px;
+    opacity: 1;
+    padding: 0.1rem;
+    margin-top: 0.5rem;
+    border-top: 1px solid #e5e7eb;
+    width: 100%;
+    max-width: 100%;
+    box-sizing: border-box;
+}
+
+.property-item {
+    margin-bottom: 0.15rem;
+    padding: 0.5rem;
+    border-left: 2px solid #e5e7eb;
+    transition: all 0.2s ease;
+    font-size: 0.8rem;
+    background-color: white;
+    border-radius: 4px;
+}
+
+.property-item:hover {
+    border-left-color: #3b82f6;
+}
+
+.property-header {
+    margin-bottom: 0.25rem;
+}
+
+.property-title {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    flex-wrap: wrap;
+}
+
+.property-name {
+    font-weight: 600;
+    color: #1e293b;
+    font-size: 0.85rem;
+    background-color: #f8fafc;
+    padding: 0.2rem 0.4rem;
+    border-radius: 4px;
+    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+    display: inline-block;
+}
+
+.property-type {
+    color: #64748b;
+    font-size: 0.65rem;
+    padding: 0.1rem 0.3rem;
+    background: #f1f5f9;
+    border-radius: 3px;
+    font-family: 'Courier New', monospace;
+    margin-left: 0.3rem;
+}
+
+.property-desc {
+    color: #6b7280;
+    font-size: 0.7rem;
+    margin-left: 0.5rem;
+    display: inline-block;
+    font-style: italic;
+}
+
+.property-default {
+    font-size: 0.75rem;
+    color: #6b7280;
+    margin-top: 0.15rem;
+}
+
+.property-default code {
+    background: #f1f5f9;
+    padding: 0.2rem 0.4rem;
+    border-radius: 4px;
+    font-family: 'Courier New', monospace;
+    font-size: 0.85rem;
+}
+
+.required-fields {
+    border-left: 2px solid #64748b;
+    padding: 0.25rem 0.5rem;
+    margin-bottom: 0.5rem;
+    font-size: 0.8rem;
+    border-radius: 2px;
+    color: #64748b;
+}
+.required-star {
+    color: #dc2626;
+    margin-left: 2px;
+    font-weight: bold;
+}
+
+
+/* Ensure proper container behavior for the widget */
+.details-widget-container {
+    width: 100%;
+    max-width: 100%;
+    box-sizing: border-box;
+    position: relative;
+    margin: 0;
+    padding: 0;
+    overflow: hidden;
+}
+
+.nested-properties {
+    margin: 0.25rem 0 0.25rem 0.5rem;
+    padding-left: 0.5rem;
+    border-left: 1px solid #e5e7eb;
+    font-size: 0.8rem;
+}
+
+.nested-property-item {
+    margin-bottom: 0.5rem;
+    padding: 0.25rem 0.5rem;
+}
+
+.nested-property-item .property-name {
+    font-size: 0.85rem;
+}
+
+.nested-property-item .property-type {
+    font-size: 0.8rem;
+    padding: 0.1rem 0.3rem;
+}
+
+.nested-property-item .property-desc {
+    font-size: 0.8rem;
+    margin-top: 0.25rem;
+    color: #64748b;
+}