imcp 0.0.13 → 0.0.15

package/src/utils/githubUtils.ts

@@ -9,6 +9,30 @@ import { SETTINGS_DIR } from '../core/constants.js';
 
 const execAsync = util.promisify(exec);
 
+/**
+ * Get the latest version available for a GitHub repository
+ * @param execPromise The promise-based exec function
+ * @param repository The GitHub repository in format 'owner/repo'
+ * @returns The latest version or tag
+ */
+export async function getGitHubLatestVersion(execPromise: (command: string) => Promise<{ stdout: string; stderr: string }>, repository: string): Promise<string> {
+    try {
+        // Use GitHub CLI to get the latest release
+        const { stdout } = await execPromise(`gh release view --repo ${repository} --json tagName --jq .tagName`);
+        const latestTag = stdout.trim();
+
+        // Remove 'v' prefix if present
+        return latestTag.startsWith('v') ? latestTag.substring(1) : latestTag;
+    } catch (error) {
+        // If gh command fails, try to get the latest tag
+        const { stdout } = await execPromise(`git ls-remote --tags --refs https://github.com/${repository}.git | sort -t '/' -k 3 -V | tail -n 1 | awk -F/ '{print $3}'`);
+        let latestTag = stdout.trim();
+
+        // Remove 'v' prefix if present
+        return latestTag.startsWith('v') ? latestTag.substring(1) : latestTag;
+    }
+}
+
 interface DownloadGithubReleaseResult {
     version: string;
     downloadPath: string;

package/src/utils/macroExpressionUtils.ts

@@ -0,0 +1,121 @@
+import { Logger } from './logger.js';
+import { getPythonPackagePath, getSystemPythonPackageDirectory, GetBrowserPath } from './osUtils.js';
+import { ServerInstallOptions } from '../core/types.js'; // Adjusted path
+import * as fsSync from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+
+export const MACRO_EXPRESSIONS = {
+    PYTHON_PACKAGE: '${PYTHON_PACKAGE}',
+    NPMPATH: '${NPMPATH}',
+    BROWSER_PATH: '${BROWSER_PATH}',
+} as const;
+
+// Define a map for macro keys to their resolver functions
+export const MacroResolverFunctions: {
+    [key: string]: (finalConfig: any, options: ServerInstallOptions) => Promise<string | undefined>;
+} = {
+    [MACRO_EXPRESSIONS.PYTHON_PACKAGE]: resolvePythonPackageMacro,
+    [MACRO_EXPRESSIONS.NPMPATH]: resolveNpmPathMacro,
+    [MACRO_EXPRESSIONS.BROWSER_PATH]: resolveBrowserPathMacro,
+};
+
+/**
+ * Resolves the path for the ${PYTHON_PACKAGE} macro.
+ * It considers the pythonEnv setting and falls back to system Python.
+ * Also updates finalConfig.command if it's 'python' and pythonEnv is used.
+ * @param finalConfig The configuration object (mutated for command).
+ * @param options Server installation options.
+ * @returns The resolved Python package path or undefined.
+ */
+export async function resolvePythonPackageMacro(finalConfig: any, options: ServerInstallOptions): Promise<string | undefined> {
+    const pythonEnv = options.settings?.pythonEnv;
+    if (pythonEnv) {
+        Logger.debug(`Python environment specified for ${MACRO_EXPRESSIONS.PYTHON_PACKAGE}: ${pythonEnv}`);
+        const pythonDir = getPythonPackagePath(pythonEnv);
+        if (pythonDir) {
+            if (finalConfig.command === 'python') {
+                Logger.debug(`Replacing command 'python' with specified pythonEnv: ${pythonEnv} due to ${MACRO_EXPRESSIONS.PYTHON_PACKAGE} resolution`);
+                finalConfig.command = pythonEnv;
+            }
+            return pythonDir;
+        }
+        Logger.debug(`Could not determine directory for pythonEnv: ${pythonEnv}. ${MACRO_EXPRESSIONS.PYTHON_PACKAGE} will not be replaced using this path.`);
+        return undefined;
+    } else {
+        Logger.debug(`No Python environment specified. Attempting to find system Python for ${MACRO_EXPRESSIONS.PYTHON_PACKAGE}.`);
+        const pythonDir = await getSystemPythonPackageDirectory();
+        if (pythonDir) {
+            return pythonDir;
+        }
+        Logger.debug(`Could not find system Python directory for ${MACRO_EXPRESSIONS.PYTHON_PACKAGE}.`);
+        return undefined;
+    }
+}
+
+/**
+ * Resolves the actual NPM module path.
+ * It checks a provided path, then NVM, then global npm.
+ * @param providedNpmPath An optional, pre-configured NPM path.
+ * @returns The resolved NPM module path or undefined if an error occurs.
+ */
+export function resolveNpmModulePath(providedNpmPath: string | undefined): string {
+    if (providedNpmPath) {
+        return `${providedNpmPath}/node_modules`;
+    }
+
+    const nvmHome = process.env.NVM_HOME;
+    if (nvmHome) {
+        try {
+            const nodeVersion = execSync('node -v').toString().trim();
+            const nvmNodePath = path.join(nvmHome, nodeVersion);
+            // Check if this path exists
+            try {
+                fsSync.accessSync(nvmNodePath);
+                Logger.debug(`Resolved ${MACRO_EXPRESSIONS.NPMPATH} via NVM to: ${nvmNodePath}`);
+                return nvmNodePath;
+            } catch (error) {
+                Logger.debug(`NVM controlled path doesn't exist: ${nvmNodePath}, will try global npm`);
+            }
+        } catch (error) {
+            Logger.debug(`Error determining Node version for NVM: ${error}, will use global npm`);
+        }
+    }
+
+    const globalNpmPath = execSync('npm root -g').toString().trim();
+    Logger.debug(`Resolved ${MACRO_EXPRESSIONS.NPMPATH} via global npm to: ${globalNpmPath}`);
+    return globalNpmPath;
+}
+
+/**
+ * Resolves the path to an NPM module for the ${NPMPATH} macro.
+ * Uses the resolveNpmModulePath function.
+ * @param _finalConfig Not used by this resolver.
+ * @param options Server installation options, may contain npmPath.
+ * @returns The resolved NPM path or undefined if an error occurs.
+ */
+export async function resolveNpmPathMacro(_finalConfig: any, options: ServerInstallOptions): Promise<string | undefined> {
+    Logger.debug(`Resolving ${MACRO_EXPRESSIONS.NPMPATH}. Provided npmPath from settings: ${options.settings?.npmPath}`);
+    try {
+        return resolveNpmModulePath(options.settings?.npmPath);
+    } catch (error) {
+        Logger.error(`Failed to resolve ${MACRO_EXPRESSIONS.NPMPATH}:`, error);
+        return undefined;
+    }
+}
+
+/**
+ * Resolves the path for the ${BROWSER_PATH} macro.
+ * @returns The system's browser path or undefined.
+ */
+export async function resolveBrowserPathMacro(): Promise<string | undefined> {
+    Logger.debug(`Resolving ${MACRO_EXPRESSIONS.BROWSER_PATH}`);
+    try {
+        const browserPath = await GetBrowserPath();
+        Logger.debug(`Resolved ${MACRO_EXPRESSIONS.BROWSER_PATH} to: ${browserPath}`);
+        return browserPath;
+    } catch (error) {
+        Logger.error(`Failed to get system browser path for ${MACRO_EXPRESSIONS.BROWSER_PATH}:`, error);
+        return undefined;
+    }
+}

package/src/utils/osUtils.ts

@@ -95,10 +95,7 @@ export async function installCLI(tool: 'gh' | 'git'): Promise<void> {
 
 /**
  * Refreshes the PATH environment variable for the current Node.js process
- * This is necessary because when tools are installed using package managers,
- * they update the system PATH but the current Node process doesn't see those changes.
  */
-
 export async function refreshPathEnv(): Promise<void> {
   const osType = getOSType();
   Logger.debug({
@@ -151,6 +148,62 @@ export async function refreshPathEnv(): Promise<void> {
   }
 }
 
+/**
+ * Check if a command is available on the system
+ * Handles special cases for VS Code on different platforms
+ */
+export async function isCommandAvailable(command: string): Promise<boolean> {
+  try {
+    // For VS Code on macOS, check both command-line tool and app bundle
+    if (process.platform === 'darwin' && (command === 'code' || command === 'code-insiders')) {
+      try {
+        // Try which command first
+        await execAsync(`which ${command}`);
+        return true;
+      } catch (error) {
+        // If which fails, check application bundles
+        const systemVSCodePath = command === 'code' ?
+          '/Applications/Visual Studio Code.app' :
+          '/Applications/Visual Studio Code - Insiders.app';
+
+        try {
+          // Check system Applications first
+          await execAsync(`test -d "${systemVSCodePath}"`);
+          return true;
+        } catch (error) {
+          // If system Applications check fails, try user Applications
+          const homedir = process.env.HOME;
+          if (homedir) {
+            const userVSCodePath = command === 'code' ?
+              `${homedir}/Applications/Visual Studio Code.app` :
+              `${homedir}/Applications/Visual Studio Code - Insiders.app`;
+
+            try {
+              await execAsync(`test -d "${userVSCodePath}"`);
+              return true;
+            } catch (error) {
+              return false;
+            }
+          }
+          return false;
+        }
+      }
+    }
+
+    // For Windows, use where command
+    if (process.platform === 'win32') {
+      await execAsync(`where ${command}`);
+      return true;
+    }
+
+    // For all other cases (Unix-like systems), use which command
+    await execAsync(`which ${command}`);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
 export async function isToolInstalled(tool: 'gh' | 'git', retries = 3): Promise<boolean> {
   try {
     Logger.debug({
@@ -197,11 +250,6 @@ export async function isToolInstalled(tool: 'gh' | 'git', retries = 3): Promise<
   }
 }
 
-/**
- * Opens a URL in the default browser
- * @param url The URL to open
- * @returns A promise that resolves when the browser is launched
- */
 export async function openBrowser(url: string): Promise<void> {
   const osType = getOSType();
   Logger.debug({
@@ -250,12 +298,6 @@ export async function openBrowser(url: string): Promise<void> {
   }
 }
 
-/**
- * Gets the directory containing Python packages (site-packages) based on Python executable path.
- * Handles different Python installations (system, venv, conda) across different OS platforms.
- * @param pythonExecutablePath The full path to the Python executable
- * @returns The site-packages directory path
- */
 export function getPythonPackagePath(pythonExecutablePath: string): string {
   Logger.debug({
     action: 'get_python_package_path',
@@ -268,8 +310,39 @@ export function getPythonPackagePath(pythonExecutablePath: string): string {
 
     // Handle common Python installation patterns
     if (isWindows) {
-      // Windows: Check for Scripts directory (venv) or python.exe location
-      if (dir.endsWith('Scripts')) {
+      // Windows: Handle different Python installations
+      if (dir.endsWith('WindowsApps')) {
+        // For Windows Store Python, find the actual Python installation directory
+        const entries = fs.readdirSync(dir);
+        const pythonDir = entries.find(e => e.startsWith('PythonSoftwareFoundation.Python'));
+        if (pythonDir && pythonDir.includes('.')) {
+          // Extract version from format like "PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0"
+          const parts = pythonDir.split('.');
+          const majorVer = parts[2];
+          const minorVer = parts[3].split('_')[0];
+          const version = majorVer + minorVer; // Combines "3" and "13" to "313"
+          const localAppData = process.env.LOCALAPPDATA;
+          
+          if (localAppData) {
+            const sitePkgsPath = path.join(
+              localAppData,
+              'Packages',
+              pythonDir,
+              'LocalCache',
+              'local-packages',
+              'Python' + version,
+              'site-packages'
+            );
+            
+            Logger.debug(`Resolved Windows Store Python site-packages path: ${sitePkgsPath}`);
+            return sitePkgsPath;
+          }
+        }
+        
+        Logger.debug('Could not resolve Windows Store Python site-packages path');
+        // Fallback to user's site-packages
+        return path.join(process.env.APPDATA || '', 'Python', 'Python3', 'site-packages');
+      } else if (dir.endsWith('Scripts')) {
         // Virtual environment structure on Windows: <venv>/Scripts/python.exe
         const venvRoot = path.dirname(dir);
         return path.join(venvRoot, 'Lib', 'site-packages');
@@ -320,10 +393,6 @@ export function getPythonPackagePath(pythonExecutablePath: string): string {
   }
 }
 
-/**
- * Finds the directory of the system's default Python installation.
- * @returns The directory path or null if not found.
- */
 export async function getSystemPythonPackageDirectory(): Promise<string | null> {
   const command = process.platform === 'win32' ? 'where python' : 'which python';
 
@@ -353,10 +422,6 @@ export async function getSystemPythonPackageDirectory(): Promise<string | null>
   }
 }
 
-/**
- * Gets the path of the system's default browser.
- * @returns The path to the default browser executable.
- */
 export async function GetBrowserPath(): Promise<string> {
   const osType = getOSType();
   Logger.debug({

package/src/web/contract/serverContract.ts

@@ -0,0 +1,74 @@
+import { DependencyConfig, RegistryConfig, ServerInstallOptions, EnvVariableConfig } from '../../core/types.js';
+import { ServerSchema } from '../../core/ServerSchemaProvider.js';
+
+export interface OnboardServerConfig {
+  name: string;
+  description: string;
+  mode: 'stdio' | 'sse';
+  schemas?: string;
+  dependencies?: DependencyConfig;
+  repository?: string;
+  installation: {
+    command: string;
+    args?: string[];
+    env?: Record<string, {
+      name: string;
+      default?: string;
+      required: boolean;
+      description?: string;
+    }>;
+  };
+}
+
+export type RequirementType = 'npm' | 'pip' | 'command' | 'extension' | 'other';
+
+export interface OnboardRequirementConfig {
+  type: RequirementType;
+  name: string;
+  version: string;
+  alias?: string;
+  registry?: RegistryConfig;
+}
+
+export interface OnboardRequestBody {
+  categoryData: {
+    name: string;
+    displayName: string;
+    description?: string;
+    repository?: string;
+    requirements?: OnboardRequirementConfig[];
+    mcpServers?: OnboardServerConfig[];
+  };
+  isUpdate: boolean;
+  forExistingCategory?: boolean;
+  serverName?: string; // Optional server name for server-specific operations
+}
+
+export interface ListQueryParams {
+  local?: string;
+}
+
+export interface UpdateRequirementsRequestBody {
+  requirements: {
+    name: string;
+    updateVersion: string;
+  }[];
+}
+
+export interface InstallServersRequestBody {
+  serverList: Record<string, ServerInstallOptions>;
+}
+
+export interface UninstallServersRequestBody {
+  serverList: Record<string, { removeData?: boolean }>;
+  options: {
+    targets: string[];
+    removeData?: boolean;
+  };
+}
+
+export interface ApiResponse<T> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}

package/src/web/public/css/notifications.css

@@ -2,53 +2,84 @@
 .alert-container {
     z-index: 999999; /* Extremely high to appear above modals */
     position: fixed;
-    top: 0 !important;
-    left: 0 !important;
-    right: 0 !important;
+    top: 20px; /* Adjusted for top-right positioning */
+    right: 20px; /* Adjusted for top-right positioning */
     display: flex;
     flex-direction: column;
-    align-items: center;
+    align-items: flex-end; /* Align items to the right */
     gap: 10px;
     pointer-events: none; /* Allow clicking through the container */
+    max-width: 350px; /* Max width for the container */
 }
 
 .alert {
-    min-width: 350px;
-    max-width: 500px;
-    box-shadow: 0 8px 24px rgba(0, 0, 0, 0.25);
+    min-width: 300px; /* Adjusted min-width */
+    max-width: 100%;   /* Alert can take full width of container */
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15); /* Softer shadow */
     backdrop-filter: blur(8px);
-    border-width: 2px;
+    border-width: 1px; /* Thinner border */
+    border-radius: 8px; /* Rounded corners */
     pointer-events: auto; /* Re-enable pointer events for alerts */
-    padding: 0.75rem 1.5rem;
-    font-size: 1.1rem;
+    padding: 12px 20px; /* Adjusted padding */
+    font-size: 0.95rem; /* Slightly smaller font size */
     font-weight: 500;
-    margin-top: 10px;
+    display: flex; /* For icon and text alignment */
+    align-items: center; /* Vertically center icon and text */
+    opacity: 0; /* Start hidden for animation */
+    transform: translateX(100%); /* Start off-screen for slide-in */
+    transition: opacity 0.3s ease-out, transform 0.3s ease-out; /* Smooth animation */
+}
+
+.alert.show {
+    opacity: 1;
+    transform: translateX(0);
 }
 
 .alert:first-child {
     margin-top: 0;
 }
 
+.alert-icon {
+    margin-right: 10px; /* Space between icon and text */
+    font-size: 1.2rem; /* Icon size */
+}
+
 .alert.alert-success {
-    background-color: rgba(25, 135, 84, 0.98);
-    border-color: #146c43;
+    background-color: rgba(30, 136, 229, 0.9); /* Blue for success */
+    border-color: #1e88e5;
     color: white;
-    font-weight: 500;
 }
 
 .alert.alert-error {
-    background-color: rgba(220, 53, 69, 0.98);
-    border-color: #b02a37;
+    background-color: rgba(229, 57, 53, 0.9); /* Red for error */
+    border-color: #e53935;
     color: white;
-    font-weight: 500;
+}
+
+.alert.alert-info {
+    background-color: rgba(2, 136, 209, 0.9); /* Light blue for info */
+    border-color: #0288d1;
+    color: white;
+}
+
+.alert.alert-warning {
+    background-color: rgba(251, 192, 45, 0.9); /* Yellow for warning */
+    border-color: #fbc02d;
+    color: #333; /* Darker text for better contrast on yellow */
 }
 
 .alert .btn-close {
     filter: brightness(0) invert(1);
     opacity: 0.8;
     padding: 0.75rem;
+    margin-left: auto; /* Push close button to the right */
 }
 
+.alert.alert-warning .btn-close {
+    filter: none; /* No filter for warning close button for better visibility */
+}
+
+
 /* When modal is open, add backdrop to alerts */
 .modal.show ~ .alert-container .alert {
     box-shadow: 0 8px 32px rgba(0, 0, 0, 0.35);

package/src/web/public/css/onboard.css

@@ -0,0 +1,107 @@
+/* Onboarding form styles */
+.requirement-item,
+.server-item {
+    background-color: #ffffff;
+    transition: all 0.2s ease;
+}
+
+.requirement-item:hover,
+.server-item:hover {
+    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+}
+
+.registry-config,
+.installation-config,
+.env-variables {
+    background-color: #f9fafb;
+    border-radius: 0.5rem;
+    padding: 0.75rem; /* Reduced padding */
+    margin-top: 0.75rem; /* Reduced margin-top */
+}
+
+.registry-github,
+.registry-artifacts {
+    background-color: #ffffff;
+    border-radius: 0.5rem;
+    padding: 0.75rem; /* Reduced padding */
+}
+
+/* Order field styling */
+input[type="number"][name$=".order"] {
+    -moz-appearance: textfield;
+}
+
+input[type="number"][name$=".order"]::-webkit-outer-spin-button,
+input[type="number"][name$=".order"]::-webkit-inner-spin-button {
+    -webkit-appearance: none;
+    margin: 0;
+}
+
+input[type="number"][name$=".order"]:focus {
+    border-color: #3b82f6;
+    outline: none;
+    box-shadow: 0 0 0 2px rgba(59, 130, 246, 0.2);
+}
+
+/* Collapsible sections */
+.collapsible-content {
+  overflow: hidden;
+  transition: max-height 0.3s ease-out, opacity 0.3s ease-out, padding 0.3s ease-out, margin 0.3s ease-out;
+  opacity: 1;
+  max-height: 1000px; /* Adjust as needed, should be larger than the content */
+}
+
+.collapsible-content.hidden {
+  max-height: 0;
+  opacity: 0;
+  padding-top: 0 !important; /* Use important to override potential inline styles or more specific selectors */
+  padding-bottom: 0 !important;
+  margin-top: 0 !important;
+  margin-bottom: 0 !important; /* Ensure bottom margin also collapses */
+  border-top-width: 0;
+  border-bottom-width: 0;
+  overflow: hidden; /* Ensure content is clipped during transition */
+}
+
+/* Styling for the clickable header of collapsible sections */
+.collapsible-header {
+  cursor: pointer;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.collapsible-header i {
+  transition: transform 0.3s ease;
+}
+
+.collapsible-content.hidden + .collapsible-header i {
+  transform: rotate(-90deg);
+}
+
+/* Specific styling for scrollable server content */
+.server-content-scrollable {
+  /* This max-height is for when the section is *expanded*.
+     The .collapsible-content.hidden will still set max-height to 0 for collapse.
+     The general .collapsible-content max-height is a fallback for other sections.
+  */
+  max-height: 60vh; /* Reduced max-height for compactness */
+  overflow-y: auto; /* Add vertical scrollbar when content exceeds max-height */
+  padding-right: 0.5rem; /* Add a little padding so scrollbar doesn't overlap content too much */
+  /* Ensure it inherits or has its own transitions for smooth animation */
+  transition: max-height 0.3s ease-out, opacity 0.3s ease-out, padding 0.3s ease-out, margin 0.3s ease-out;
+  opacity: 1; /* Explicitly set opacity for visible state */
+}
+
+/* Ensure that when server-content-scrollable is hidden, its specific max-height is overridden */
+.server-content-scrollable.hidden {
+    max-height: 0 !important; /* Override the 60vh for hidden state */
+    opacity: 0 !important; /* Ensure opacity transition for hidden state */
+    overflow-y: hidden; /* Hide scrollbar when collapsed */
+    padding-top: 0 !important;
+    padding-bottom: 0 !important;
+    padding-left: 0 !important; /* Ensure all paddings are zeroed */
+    padding-right: 0 !important;
+    margin-top: 0 !important;
+    margin-bottom: 0 !important;
+}