imcp 0.0.1

package/src/utils/logger.ts

@@ -0,0 +1,101 @@
+import fs from 'fs';
+import path from 'path';
+import { SETTINGS_DIR } from '../core/constants.js';
+
+export class Logger {
+  private static verbose = false;
+  private static fileLoggingEnabled = true;
+  private static logsDir = path.join(SETTINGS_DIR, 'logs');
+
+  static setVerbose(isVerbose: boolean): void {
+    this.verbose = isVerbose;
+  }
+
+  static setFileLogging(enabled: boolean): void {
+    this.fileLoggingEnabled = enabled;
+  }
+
+  private static async ensureLogsDirExists(): Promise<void> {
+    try {
+      await fs.promises.mkdir(this.logsDir, { recursive: true });
+    } catch (error) {
+      console.error(`Failed to create logs directory: ${error instanceof Error ? error.message : String(error)}`);
+      // Disable file logging if directory creation fails
+      this.fileLoggingEnabled = false;
+    }
+  }
+
+  private static getLogFileName(): string {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const day = String(now.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}.log`;
+  }
+
+  private static getTimestamp(): string {
+    return new Date().toISOString();
+  }
+
+  private static async writeToLogFile(level: string, content: string): Promise<void> {
+    if (!this.fileLoggingEnabled) return;
+
+    try {
+      await this.ensureLogsDirExists();
+      const logFile = path.join(this.logsDir, this.getLogFileName());
+      const logEntry = `[${this.getTimestamp()}] [${level}] ${content}\n`;
+
+      await fs.promises.appendFile(logFile, logEntry, { encoding: 'utf8' });
+    } catch (error) {
+      console.error(`Failed to write to log file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  static async log(message: string): Promise<void> {
+    console.log(message);
+    await this.writeToLogFile('INFO', message);
+  }
+
+  static async debug(message: string | object): Promise<void> {
+    let formattedMessage: string;
+
+    if (typeof message === 'object') {
+      formattedMessage = JSON.stringify(message, null, 2);
+      if (this.verbose) {
+        console.log(formattedMessage);
+      }
+    } else {
+      formattedMessage = message;
+      if (this.verbose) {
+        console.log(message);
+      }
+    }
+
+    if (this.verbose) {
+      await this.writeToLogFile('DEBUG', formattedMessage);
+    }
+  }
+
+  static async error(message: string, error?: unknown): Promise<void> {
+    console.error(message);
+
+    let logMessage = message;
+
+    if (this.verbose && error) {
+      if (error instanceof Error) {
+        const errorDetails = {
+          name: error.name,
+          message: error.message,
+          stack: error.stack
+        };
+        console.error('Error details:', errorDetails);
+        logMessage += `\nError details: ${JSON.stringify(errorDetails, null, 2)}`;
+      } else {
+        console.error('Error details:', error);
+        logMessage += `\nError details: ${JSON.stringify(error, null, 2)}`;
+      }
+    }
+
+    await this.writeToLogFile('ERROR', logMessage);
+  }
+}

package/src/utils/osUtils.ts

@@ -0,0 +1,250 @@
+import { OSType } from '../core/types.js';
+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(): OSType {
+  const platform = os.platform();
+  Logger.debug({
+    action: 'get_os_type',
+    platform
+  });
+  
+  switch (platform) {
+    case 'win32':
+      return OSType.Windows;
+    case 'darwin':
+      return OSType.MacOS;
+    case 'linux':
+      return OSType.Linux;
+    default:
+      const error = `Unsupported operating system: ${platform}`;
+      Logger.error(error);
+      throw new Error(error);
+  }
+}
+
+export async function installCLI(tool: 'gh' | 'git'): Promise<void> {
+  const osType = getOSType();
+  Logger.debug({
+    action: 'install_cli',
+    tool,
+    osType
+  });
+  
+  try {
+    switch (osType) {
+      case OSType.Windows:
+        if (tool === 'git') {
+          await execAsync('winget install --id Git.Git -e --source winget --silent');
+        } else {
+          await execAsync('winget install --id GitHub.cli --silent');
+        }
+        // Refresh PATH environment variable after installation
+        await refreshPathEnv();
+        break;
+        
+      case OSType.MacOS:
+        if (tool === 'git') {
+          await execAsync('brew install git');
+        } else {
+          await execAsync('brew install gh');
+        }
+        // On macOS, we may need to source profile files
+        if (tool === 'git') {
+          await execAsync('source ~/.zshrc || source ~/.bash_profile || source ~/.bashrc || true');
+        }
+        break;
+        
+      case OSType.Linux:
+        if (tool === 'git') {
+          await execAsync('sudo apt-get update && sudo apt-get install -y git');
+        } else {
+          await execAsync('curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg && sudo chmod go+r /usr/share/keyrings/githubcli-archive-keyring.gpg && echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null && sudo apt update && sudo apt install -y gh');
+        }
+        // Source bash profile to refresh PATH
+        await execAsync('source ~/.bashrc || source ~/.profile || true');
+        break;
+        
+      default:
+        throw new Error(`Unsupported operating system for installing ${tool}`);
+    }
+    
+    // Wait a moment for system to register the new binaries
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    
+    Logger.debug({
+      action: 'install_cli_success',
+      tool,
+      osType
+    });
+  } catch (error) {
+    Logger.error('Failed to install CLI tool', {
+      tool,
+      osType,
+      error
+    });
+    throw error;
+  }
+}
+
+/**
+ * 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({
+    action: 'refresh_path_env',
+    osType
+  });
+
+  try {
+    switch (osType) {
+      case OSType.Windows:
+        // On Windows, get the PATH from registry
+        const { stdout: winPath } = await execAsync('powershell -command "[Environment]::GetEnvironmentVariable(\'Path\', \'Machine\') + \';\' + [Environment]::GetEnvironmentVariable(\'Path\', \'User\')"');
+        if (winPath) {
+          process.env.PATH = winPath.trim();
+          Logger.debug('Refreshed PATH from Windows registry');
+        }
+        break;
+        
+      case OSType.MacOS:
+      case OSType.Linux:
+        // On Unix systems, typical installation locations if PATH isn't updated
+        const commonPaths = [
+          '/usr/local/bin',
+          '/usr/bin',
+          '/bin',
+          '/usr/sbin',
+          '/sbin',
+          '/usr/local/git/bin',
+          '/opt/homebrew/bin', // For M1 Macs
+          `${os.homedir()}/.local/bin`
+        ];
+        
+        // Ensure these paths are in process.env.PATH
+        if (process.env.PATH) {
+          const currentPaths = process.env.PATH.split(':');
+          const newPaths = [...new Set([...currentPaths, ...commonPaths])];
+          process.env.PATH = newPaths.join(':');
+          Logger.debug('Expanded PATH with common Unix binary locations');
+        }
+        break;
+    }
+
+    Logger.debug({
+      action: 'refresh_path_env_success',
+      path: process.env.PATH
+    });
+  } catch (error) {
+    Logger.error('Failed to refresh PATH environment variable', error);
+    // Continue execution even if PATH refresh fails
+  }
+}
+
+export async function isToolInstalled(tool: 'gh' | 'git', retries = 3): Promise<boolean> {
+  try {
+    Logger.debug({
+      action: 'check_tool_installed',
+      tool,
+      retries
+    });
+    
+    // Try to execute tool command
+    try {
+      await execAsync(`${tool} --version`);
+      Logger.debug({
+        action: 'check_tool_installed_success',
+        tool,
+        installed: true
+      });
+      return true;
+    } catch (error) {
+      // If we have retries left, refresh PATH and try again
+      if (retries > 0) {
+        Logger.debug(`${tool} not found, refreshing PATH and retrying...`);
+        
+        // Refresh environment PATH variable
+        await refreshPathEnv();
+        
+        // Wait a moment before retrying
+        await new Promise(resolve => setTimeout(resolve, 500));
+        
+        // Recursive retry with decremented counter
+        return isToolInstalled(tool, retries - 1);
+      }
+      
+      // No retries left, tool is not installed
+      Logger.debug({
+        action: 'check_tool_installed_success',
+        tool,
+        installed: false
+      });
+      return false;
+    }
+  } catch (error) {
+    Logger.error(`Error checking if ${tool} is installed`, error);
+    return false;
+  }
+}
+
+/**
+ * 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({
+    action: 'open_browser',
+    url,
+    osType
+  });
+
+  try {
+    switch (osType) {
+      case OSType.Windows:
+        await execAsync(`start ${url}`);
+        break;
+      case OSType.MacOS:
+        await execAsync(`open ${url}`);
+        break;
+      case OSType.Linux:
+        // Try different commands that might be available
+        try {
+          await execAsync(`xdg-open ${url}`);
+        } catch (error) {
+          // Try alternative commands
+          try {
+            await execAsync(`sensible-browser ${url}`);
+          } catch (error) {
+            await execAsync(`gnome-open ${url}`);
+          }
+        }
+        break;
+      default:
+        throw new Error(`Unsupported operating system for opening browser`);
+    }
+    
+    Logger.debug({
+      action: 'open_browser_success',
+      url,
+      osType
+    });
+  } catch (error) {
+    Logger.error('Failed to open browser', {
+      url,
+      osType,
+      error
+    });
+    // Don't throw the error - just log it and continue
+  }
+}

package/src/web/public/css/modal.css

@@ -0,0 +1,250 @@
+/* Import Inter font */
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
+
+/* Base styles */
+body {
+    font-family: 'Inter', system-ui, -apple-system, sans-serif;
+}
+
+/* Modal container */
+.modal {
+    display: none;
+    position: fixed;
+    z-index: 50;
+    left: 0;
+    top: 0;
+    width: 100%;
+    height: 100%;
+    overflow: auto;
+    background-color: rgba(0, 0, 0, 0.5);
+    backdrop-filter: blur(4px);
+    animation: fadeIn 0.2s ease-out;
+/* Debug: Ensure loading modal is always visible and content is not hidden */
+#installLoadingModal {
+    z-index: 3000 !important;
+    display: none;
+}
+#installLoadingModal .modal-content {
+    z-index: 3100 !important;
+    pointer-events: auto;
+    background: #fff !important;
+    border: 3px solid #3498db !important;
+    color: #222 !important;
+    min-width: 320px;
+    min-height: 120px;
+    opacity: 1 !important;
+    box-shadow: 0 0 16px #3498db;
+}
+/* Loading modal always on top */
+#installLoadingModal {
+    z-index: 2000 !important;
+    display: none;
+}
+#installLoadingModal .modal-content {
+    z-index: 2100 !important;
+    pointer-events: auto;
+}
+}
+
+/* Modal content */
+.modal-content {
+    background-color: #ffffff;
+    margin: 10% auto;
+    padding: 2rem;
+    border: none;
+    border-radius: 1rem;
+    width: 90%;
+    max-width: 550px;
+    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);
+    transition: all 0.3s ease-out;
+    animation: slideIn 0.3s ease-out;
+}
+
+/* Close button */
+.close {
+    position: absolute;
+    right: 1.5rem;
+    top: 1.5rem;
+    font-size: 1.5rem;
+    font-weight: 600;
+    color: #6b7280;
+    cursor: pointer;
+    width: 32px;
+    height: 32px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 50%;
+    transition: color 0.2s ease;
+}
+
+.close:hover {
+    background-color: #f3f4f6;
+    color: #111827;
+}
+
+/* Sections layout */
+.modal-sections {
+    margin-top: 1.5rem;
+}
+
+.section-container {
+    padding: 1.25rem;
+    margin-bottom: 1.5rem;
+    border: 1px solid #e5e7eb;
+    border-radius: 0.75rem;
+    background-color: #f9fafb;
+    transition: all 0.2s ease;
+}
+
+.section-title {
+    margin-bottom: 1rem;
+}
+
+/* Client grid */
+.client-grid {
+    display: grid;
+    grid-template-columns: 1fr;
+    gap: 0.75rem;
+}
+
+/* Client item styling */
+.client-item {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.75rem 1rem;
+    border-radius: 0.5rem;
+    border: 2px solid #e5e7eb;
+    background-color: #ffffff;
+    transition: all 0.2s ease;
+    cursor: pointer;
+    user-select: none;
+}
+
+.client-item:hover {
+    background-color: #f3f4f6;
+    transform: translateY(-1px);
+    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+}
+
+.client-item.selected {
+    border-color: #2563eb;
+    background-color: #eff6ff;
+}
+
+/* Client item info section */
+.client-info {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+/* Status badges */
+.status-badge {
+    display: inline-flex;
+    align-items: center;
+    padding: 0.25rem 0.75rem;
+    border-radius: 9999px;
+    font-size: 0.75rem;
+    font-weight: 500;
+}
+
+.status-badge.installed {
+    background-color: #dcfce7;
+    color: #166534;
+}
+
+.status-badge.not-installed {
+    background-color: #fee2e2;
+    color: #991b1b;
+}
+
+.status-badge.pending {
+    background-color: #fef3c7;
+    color: #92400e;
+}
+
+/* Non-selectable items (installed or in-progress) */
+.client-item.non-selectable {
+    background-color: #f9fafb;
+    cursor: default;
+    opacity: 0.85;
+}
+
+.client-item.non-selectable:hover {
+    transform: none;
+    box-shadow: none;
+}
+
+/* Specific styling for installed items */
+.client-item.installed-item {
+    background-color: #f0fdf4;
+}
+
+/* Specific styling for in-progress items */
+.client-item.in-progress-item {
+    background-color: #fef3c7;
+}
+
+/* Environment variables section */
+#modalEnvInputs input {
+    width: 100%;
+    padding: 0.75rem 1rem;
+    border: 1px solid #e5e7eb;
+    border-radius: 0.5rem;
+    transition: all 0.2s ease;
+}
+
+#modalEnvInputs input: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;
+    color: white;
+    padding: 0.625rem 1.25rem;
+    border-radius: 0.5rem;
+    font-weight: 500;
+    transition: all 0.2s ease;
+}
+
+.submit-button:hover {
+    background-color: #1d4ed8;
+    transform: translateY(-1px);
+}
+
+.submit-button:active {
+    transform: translateY(0);
+}
+
+/* Animations */
+@keyframes fadeIn {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+
+@keyframes slideIn {
+    from {
+        opacity: 0;
+        transform: translateY(-20px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+ /* Center loading icon in loading modal */
+#installLoadingModal .loading-icon {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    width: 100%;
+    margin-bottom: 8px;
+}

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

@@ -0,0 +1,70 @@
+/* Alert container */
+.alert-container {
+    z-index: 999999; /* Extremely high to appear above modals */
+    position: fixed;
+    top: 0 !important;
+    left: 0 !important;
+    right: 0 !important;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 10px;
+    pointer-events: none; /* Allow clicking through the container */
+}
+
+.alert {
+    min-width: 350px;
+    max-width: 500px;
+    box-shadow: 0 8px 24px rgba(0, 0, 0, 0.25);
+    backdrop-filter: blur(8px);
+    border-width: 2px;
+    pointer-events: auto; /* Re-enable pointer events for alerts */
+    padding: 0.75rem 1.5rem;
+    font-size: 1.1rem;
+    font-weight: 500;
+    margin-top: 10px;
+}
+
+.alert:first-child {
+    margin-top: 0;
+}
+
+.alert.alert-success {
+    background-color: rgba(25, 135, 84, 0.98);
+    border-color: #146c43;
+    color: white;
+    font-weight: 500;
+}
+
+.alert.alert-error {
+    background-color: rgba(220, 53, 69, 0.98);
+    border-color: #b02a37;
+    color: white;
+    font-weight: 500;
+}
+
+.alert .btn-close {
+    filter: brightness(0) invert(1);
+    opacity: 0.8;
+    padding: 0.75rem;
+}
+
+/* When modal is open, add backdrop to alerts */
+.modal.show ~ .alert-container .alert {
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.35);
+    backdrop-filter: blur(12px);
+}
+
+/* Modal customization */
+.modal-content {
+    border: none;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+}
+
+.modal-header {
+    border-bottom: 1px solid rgba(0, 0, 0, 0.05);
+}
+
+.modal-footer {
+    border-top: 1px solid rgba(0, 0, 0, 0.05);
+}