imcp 0.0.4 → 0.0.5

package/dist/utils/githubUtils.d.ts

@@ -0,0 +1,11 @@
+import { RegistryConfig, RequirementConfig } from '../core/types.js';
+/**
+ * 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 declare function handleGitHubRelease(requirement: RequirementConfig, registry: RegistryConfig['githubRelease']): Promise<{
+    resolvedVersion: string;
+    resolvedPath: string;
+}>;

package/dist/utils/githubUtils.js

@@ -0,0 +1,88 @@
+import { exec } from 'child_process';
+import util from 'util';
+import fs from 'fs/promises';
+import path from 'path';
+import { extractZipFile } from './clientUtils.js';
+import { Logger } from './logger.js';
+import { SETTINGS_DIR } from '../core/constants.js';
+const execAsync = util.promisify(exec);
+/**
+ * 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, registry) {
+    if (!registry) {
+        throw new Error('GitHub release registry configuration 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');
+    }
+    let version = requirement.version;
+    let resolvedAssetName = assetName || '';
+    let resolvedAssetsName = assetsName || '';
+    const { stdout } = await execAsync(`gh release view --repo ${repository} --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;
+    if (assetsName) {
+        resolvedAssetsName = assetsName.replace('${latest}', version).replace('${version}', version);
+    }
+    if (assetName) {
+        resolvedAssetName = assetName.replace('${latest}', version).replace('${version}', version);
+    }
+    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');
+    }
+    // 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}"`);
+    }
+    // Handle zip file extraction if the downloaded file is a zip
+    if (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);
+            try {
+                await fs.access(assetPath);
+                return { resolvedVersion: version, resolvedPath: assetPath };
+            }
+            catch (error) {
+                throw new Error(`Asset ${resolvedAssetName} not found in extracted directory ${extractDir}`);
+            }
+        }
+        else {
+            assetPath = path.join(extractDir, path.basename(pattern, '.zip') + '.tgz');
+        }
+        // If no specific asset is required, return the extraction directory
+        return { resolvedVersion: version, resolvedPath: extractDir };
+    }
+    return { resolvedVersion: version, resolvedPath: downloadPath };
+}
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=githubUtils.js.map

package/dist/utils/osUtils.d.ts

@@ -14,3 +14,20 @@ export declare function isToolInstalled(tool: 'gh' | 'git', retries?: number): P
  * @returns A promise that resolves when the browser is launched
  */
 export declare 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 declare 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 declare function getSystemPythonPackageDirectory(): Promise<string | null>;
+/**
+ * Gets the path of the system's default browser.
+ * @returns The path to the default browser executable.
+ */
+export declare function GetBrowserPath(): Promise<string>;

package/dist/utils/osUtils.js

@@ -3,6 +3,8 @@ import os from 'os';
 import { exec } from 'child_process';
 import util from 'util';
 import { Logger } from './logger.js';
+import fs from 'fs';
+import path from 'path';
 const execAsync = util.promisify(exec);
 export function getOSType() {
     const platform = os.platform();
@@ -232,4 +234,186 @@ export async function openBrowser(url) {
         // Don't throw the error - just log it and continue
     }
 }
+/**
+ * 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) {
+    Logger.debug({
+        action: 'get_python_package_path',
+        pythonExecutablePath
+    });
+    try {
+        const dir = path.dirname(pythonExecutablePath);
+        const isWindows = process.platform === 'win32';
+        // Handle common Python installation patterns
+        if (isWindows) {
+            // Windows: Check for Scripts directory (venv) or python.exe location
+            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');
+            }
+            else if (dir.toLowerCase().includes('python')) {
+                // System Python or Conda on Windows
+                return path.join(dir, 'Lib', 'site-packages');
+            }
+        }
+        else {
+            // Unix systems (MacOS/Linux)
+            if (dir.endsWith('bin')) {
+                // Virtual environment structure on Unix: <venv>/bin/python
+                const venvRoot = path.dirname(dir);
+                // Try to find python version-specific site-packages
+                const libDir = path.join(venvRoot, 'lib');
+                if (fs.existsSync(libDir)) {
+                    const pythonDirs = fs.readdirSync(libDir).filter(d => d.startsWith('python'));
+                    if (pythonDirs.length > 0) {
+                        // Use the first python directory found
+                        return path.join(libDir, pythonDirs[0], 'site-packages');
+                    }
+                }
+                // Fallback to a generic lib/python3/site-packages if version-specific not found
+                return path.join(venvRoot, 'lib', 'python3', 'site-packages');
+            }
+            else if (dir.toLowerCase().includes('python')) {
+                // System Python or Conda on Unix
+                const libDir = path.join(dir, 'lib');
+                if (fs.existsSync(libDir)) {
+                    const pythonDirs = fs.readdirSync(libDir).filter(d => d.startsWith('python'));
+                    if (pythonDirs.length > 0) {
+                        // Use the first python directory found
+                        return path.join(libDir, pythonDirs[0], 'site-packages');
+                    }
+                }
+                // Fallback to a generic lib/python3/site-packages
+                return path.join(dir, 'lib', 'python3', 'site-packages');
+            }
+        }
+        // Default fallback: return the original directory
+        Logger.debug('No standard Python directory structure found, using original directory');
+        return dir;
+    }
+    catch (error) {
+        Logger.error('Error getting Python package path', {
+            pythonExecutablePath,
+            error
+        });
+        return path.dirname(pythonExecutablePath);
+    }
+}
+/**
+ * Finds the directory of the system's default Python installation.
+ * @returns The directory path or null if not found.
+ */
+export async function getSystemPythonPackageDirectory() {
+    const command = process.platform === 'win32' ? 'where python' : 'which python';
+    Logger.debug({
+        action: 'get_system_python_package_directory',
+        command
+    });
+    try {
+        const { stdout } = await execAsync(command);
+        // Use the first path found, trim whitespace
+        const pythonPath = stdout.split('\n')[0].trim();
+        if (pythonPath) {
+            const packagePath = getPythonPackagePath(pythonPath);
+            Logger.debug({
+                action: 'get_system_python_package_directory_success',
+                pythonPath,
+                packagePath
+            });
+            return packagePath;
+        }
+        Logger.debug('No Python executable found');
+        return null;
+    }
+    catch (error) {
+        Logger.debug(`Could not find system python using "${command}": ${error}`);
+        return null;
+    }
+}
+/**
+ * Gets the path of the system's default browser.
+ * @returns The path to the default browser executable.
+ */
+export async function GetBrowserPath() {
+    const osType = getOSType();
+    Logger.debug({
+        action: 'get_system_browser_path',
+        osType
+    });
+    try {
+        switch (osType) {
+            case OSType.Windows: {
+                // Check for Edge first
+                const edgePaths = [
+                    `${process.env['PROGRAMFILES(X86)']}\\Microsoft\\Edge\\Application\\msedge.exe`,
+                    `${process.env['PROGRAMFILES']}\\Microsoft\\Edge\\Application\\msedge.exe`
+                ];
+                for (const path of edgePaths) {
+                    if (fs.existsSync(path)) {
+                        return path;
+                    }
+                }
+                // Then check for Chrome
+                const chromePaths = [
+                    `${process.env['PROGRAMFILES(X86)']}\\Google\\Chrome\\Application\\chrome.exe`,
+                    `${process.env['PROGRAMFILES']}\\Google\\Chrome\\Application\\chrome.exe`
+                ];
+                for (const path of chromePaths) {
+                    if (fs.existsSync(path)) {
+                        return path;
+                    }
+                }
+                break;
+            }
+            case OSType.MacOS: {
+                // Check for Edge first
+                const edgePath = '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge';
+                if (fs.existsSync(edgePath)) {
+                    return edgePath;
+                }
+                // Then check for Chrome
+                const chromePath = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+                if (fs.existsSync(chromePath)) {
+                    return chromePath;
+                }
+                // Finally check for Safari
+                const safariPath = '/Applications/Safari.app/Contents/MacOS/Safari';
+                if (fs.existsSync(safariPath)) {
+                    return safariPath;
+                }
+                break;
+            }
+            case OSType.Linux: {
+                // Try Edge first
+                try {
+                    const { stdout: edgePath } = await execAsync('which microsoft-edge');
+                    if (edgePath.trim()) {
+                        return edgePath.trim();
+                    }
+                }
+                catch { }
+                // Then try Chrome or Chromium
+                try {
+                    const { stdout: chromePath } = await execAsync('which google-chrome chromium');
+                    if (chromePath.trim()) {
+                        return chromePath.trim();
+                    }
+                }
+                catch { }
+                break;
+            }
+        }
+        // If no browser found, throw error
+        throw new Error('No supported browser found on the system');
+    }
+    catch (error) {
+        Logger.error('Failed to get browser path', error);
+        throw error;
+    }
+}
 //# sourceMappingURL=osUtils.js.map

package/dist/web/public/css/modal.css

@@ -60,7 +60,7 @@ body {
     border: none;
     border-radius: 1rem;
     width: 90%;
-    max-width: 550px;
+    max-width: 900px;
     position: relative;
     box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
     transform: translateY(0);
@@ -117,6 +117,9 @@ body {
 /* Sections layout */
 .modal-sections {
     margin-top: 1.5rem;
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 1rem;
 }
 
 .section-container {
@@ -135,10 +138,16 @@ body {
 /* Client grid */
 .client-grid {
     display: grid;
-    grid-template-columns: 1fr;
+    grid-template-columns: repeat(2, 1fr);
     gap: 0.75rem;
 }
 
+/* Make sections take full width */
+.section-container:first-child,
+.section-container:nth-child(2) {
+    grid-column: 1 / -1;
+}
+
 /* Client item styling */
 .client-item {
     display: flex;
@@ -221,10 +230,11 @@ body {
 /* Environment variables section */
 #modalEnvInputs input {
     width: 100%;
-    padding: 0.75rem 1rem;
+    padding: 0.5rem 0.75rem;
     border: 1px solid #e5e7eb;
     border-radius: 0.5rem;
     transition: all 0.2s ease;
+    height: 36px;
 }
 
 #modalEnvInputs input:focus {
@@ -233,6 +243,90 @@ body {
     box-shadow: 0 0 0 3px rgba(37, 99, 235, 0.1);
 }
 
+/* Arguments section styling */
+.args-container {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.arg-input {
+    height: 36px !important;
+    padding: 0.5rem 0.75rem !important;
+    border: 1px solid #e5e7eb;
+    border-radius: 0.5rem;
+    transition: all 0.2s ease;
+    font-family: 'Consolas', 'Monaco', monospace;
+    font-size: 0.875rem;
+}
+
+.arg-input:focus {
+    outline: none;
+    border-color: #2563eb;
+    box-shadow: 0 0 0 3px rgba(37, 99, 235, 0.1);
+}
+
+.add-arg-button {
+    align-self: flex-start;
+    display: inline-flex;
+    align-items: center;
+    gap: 0.25rem;
+    height: 32px;
+}
+
+.add-arg-button i {
+    font-size: 1.25rem;
+}
+
+.remove-arg-button {
+    padding: 0.25rem;
+    border-radius: 0.375rem;
+    transition: all 0.2s ease;
+}
+
+.remove-arg-button:hover {
+    background-color: rgba(239, 68, 68, 0.1);
+}
+
+.remove-arg-button i {
+    font-size: 1.25rem;
+}
+
+/* Arguments textarea styling */
+#install_args {
+    font-family: 'Consolas', 'Monaco', monospace;
+    font-size: 0.875rem;
+    line-height: 1.5;
+    resize: vertical;
+    transition: all 0.2s ease;
+    margin-bottom: 0.5rem;
+}
+
+#install_args:focus {
+    outline: none;
+    border-color: #2563eb;
+    box-shadow: 0 0 0 3px rgba(37, 99, 235, 0.1);
+}
+
+/* Python environment input styling */
+#python_env {
+    height: 36px !important;
+    width: 100%;
+    padding: 0.75rem 1rem;
+    border: 1px solid #e5e7eb;
+    border-radius: 0.5rem;
+    transition: all 0.2s ease;
+    font-family: 'Consolas', 'Monaco', monospace;
+    font-size: 0.875rem;
+}
+
+#python_env:focus {
+    outline: none;
+    border-color: #2563eb;
+    box-shadow: 0 0 0 3px rgba(37, 99, 235, 0.1);
+}
+
+
 /* Form buttons */
 .submit-button {
     background-color: #2563eb;

package/dist/web/public/index.html

@@ -97,6 +97,11 @@
                     <!-- Environment variable inputs will be injected here -->
                 </div>
 
+                <!-- Arguments Section -->
+                <div id="modalArguments" class="space-y-4 mb-6">
+                    <!-- Arguments will be injected here -->
+                </div>
+
                 <div class="flex justify-end space-x-4 mt-6">
                     <button type="button" onclick="closeModal()"
                         class="px-4 py-2 text-gray-600 hover:text-gray-800 font-medium rounded-md hover:bg-gray-100 transition-colors">
@@ -151,10 +156,24 @@
         window.uninstallTool = uninstallTool;
 
         // Initialize
-        document.addEventListener('DOMContentLoaded', () => {
+        document.addEventListener('DOMContentLoaded', async () => {
             setupSearch();
             setupModalOutsideClick();
-            fetchServerCategories();
+
+            // Check URL parameters for category
+            const urlParams = new URLSearchParams(window.location.search);
+            const categoryParam = urlParams.get('category');
+
+            // If we have a category parameter or last selected category
+            const lastSelected = categoryParam || localStorage.getItem('lastSelectedCategory');
+
+            // First fetch categories
+            await fetchServerCategories();
+
+            // Then show the selected category if it exists
+            if (lastSelected) {
+                showServerDetails(lastSelected);
+            }
         });
     </script>
     <script src="js/modal.js" type="module"></script>