imcp 0.1.7 → 0.1.8-dev

package/src/services/ServerService.ts

@@ -1,161 +0,0 @@
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { Logger } from '../utils/logger.js';
-import { ServerSchema, ServerSchemaProvider } from '../core/loaders/ServerSchemaProvider.js';
-import {
-  MCPServerCategory,
-  ServerInstallOptions,
-  ServerCategoryListOptions,
-  ServerOperationResult,
-  ServerUninstallOptions,
-  FeedConfiguration,
-  OperationStatus as CoreOperationStatus
-} from '../core/metadatas/types.js';
-import { mcpManager } from './MCPManager.js';
-import { OperationStatus } from '../core/onboard/OnboardStatus.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-/**
- * ServerService provides a unified interface for server management operations.
- * This layer handles business logic that's shared between the CLI and web interface.
- */
-export class ServerService {
-  /**
-   * Lists available MCP servers based on the provided options
-   */
-  async listServerCategories(options: ServerCategoryListOptions = {}): Promise<MCPServerCategory[]> {
-    return mcpManager.listServerCategories(options);
-  }
-
-  /**
-   * Gets a server by name
-   */
-  async getServerCategory(categoryName: string): Promise<MCPServerCategory | undefined> {
-    const serverCategories = await this.listServerCategories();
-    const serverCategory = serverCategories.find(s => s.name === categoryName);
-    return serverCategory;
-  }
-
-  /**
-   * Gets the schema for a specific server in a category
-   */
-  async getServerSchema(categoryName: string, serverName: string): Promise<ServerSchema | undefined> {
-    try {
-      const provider = ServerSchemaProvider.getInstance();
-      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.
-   */
-  async installMcpServer(
-    category: string,
-    serverName: string,
-    options: ServerInstallOptions = {}
-  ): Promise<ServerOperationResult> {
-    Logger.debug(`Installing MCP server: ${JSON.stringify({ category, serverName, options })}`);
-    try {
-      const result = await mcpManager.installServer(category, serverName, options);
-      Logger.debug(`Installation result: ${JSON.stringify(result)}`);
-      return result;
-    } catch (error) {
-      Logger.error(`Failed to install MCP server: ${serverName}`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Uninstall MCP server from specified client targets
-   * @param category The server category
-   * @param serverName The server name to uninstall
-   * @param options Uninstall options including target clients and data removal flags
-   */
-  async uninstallMcpServer(
-    category: string,
-    serverName: string,
-    options: ServerUninstallOptions = {}
-  ): Promise<ServerOperationResult> {
-    Logger.debug(`Uninstalling MCP server: ${JSON.stringify({ category, serverName, options })}`);
-    try {
-      const result = await mcpManager.uninstallServer(category, serverName, options);
-      Logger.debug(`Uninstallation result: ${JSON.stringify(result)}`);
-      return result;
-    } catch (error) {
-      Logger.error(`Failed to uninstall MCP server: ${serverName}`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Validates server names
-   */
-  async validateServerName(category: string, names: string | string[]): Promise<boolean> {
-    const serverNames = Array.isArray(names) ? names : [names];
-    Logger.debug(`Validating server names: ${JSON.stringify({ category, names: serverNames })}`);
-
-    // Check if category exists in feeds
-    const feedConfig = await mcpManager.getFeedConfiguration(category);
-    if (!feedConfig) {
-      Logger.debug(`Validation failed: Category "${category}" not found in feeds`);
-      return false;
-    }
-
-    // Check if all servers exist in the category's mcpServers
-    const invalidServers = serverNames.filter(name =>
-      !feedConfig.mcpServers.some(server => server.name === name)
-    );
-
-    if (invalidServers.length > 0) {
-      Logger.debug(`Validation failed: Servers "${invalidServers.join(', ')}" not found in category "${category}"`);
-      return false;
-    }
-
-    return true;
-  }
-
-  /**
-   * Formats success/error messages for operations
-   */
-  formatOperationResults(results: ServerOperationResult[]): {
-    success: boolean;
-    messages: string[];
-  } {
-    return {
-      success: results.every(r => r.success),
-      messages: results.map(r => r.message).filter((m): m is string => m !== undefined)
-    };
-  }
-
-  /**
-   * Syncs MCP server configurations from remote feed source
-   */
-  async syncFeeds(): Promise<void> {
-    return mcpManager.syncFeeds();
-  }
-
-  /**
-   * Onboards a new feed configuration
-   * @param config Feed configuration to onboard
-   */
-  async onboardFeed(config: FeedConfiguration): Promise<OperationStatus & { feedConfiguration?: FeedConfiguration }> {
-    try {
-      const result = await mcpManager.onboardFeed(config);
-      // Log based on the operation status, e.g., if it's pending or succeeded.
-      // The actual "success" of onboarding is a multi-step process (PR creation, merge).
-      Logger.log(`Feed onboarding process for '${config.name}' initiated with status: ${result.status}, ID: ${result.onboardingId}`);
-      return result;
-    } catch (error) {
-      Logger.error(`Failed to initiate feed onboarding for '${config.name}':`, error);
-      throw error; // Or return a specific error status object
-    }
-  }
-}
-
-// Export a singleton instance
-export const serverService = new ServerService();

package/src/services/TelemetryService.ts

@@ -1,59 +0,0 @@
-import * as appInsights from 'applicationinsights';
-
-export class TelemetryService {
-  private static client: appInsights.TelemetryClient | null = null;
-  private static readonly instrumentationKey = 'InstrumentationKey=c5fc06c7-a96c-4d80-9aff-bc9c933db0d1';
-  
-  static {
-    // Initialize Application Insights
-    try {
-      const client = new appInsights.TelemetryClient(TelemetryService.instrumentationKey);
-      client.config.disableAppInsights = false;
-      client.config.maxBatchSize = 250;
-      client.context.tags[client.context.keys.cloudRole] = 'imcp';
-      TelemetryService.client = client;
-      console.log('Application Insights initialized');
-    } catch (error) {
-      console.error('Failed to initialize Application Insights:', error);
-    }
-  }
-
-  static trackEvent(name: string, properties?: { [key: string]: string }): void {
-    if (!this.client) {
-      return;
-    }
-    this.client.trackEvent({ name, properties });
-  }
-
-  static trackException(error: Error, properties?: { [key: string]: string }): void {
-    if (!this.client) {
-      return;
-    }
-    this.client.trackException({ exception: error, properties });
-  }
-
-  static trackTrace(message: string, properties?: { [key: string]: string }): void {
-    if (!this.client) {
-      return;
-    }
-    this.client.trackTrace({ message, properties });
-  }
-
-  static trackMetric(name: string, value: number): void {
-    if (!this.client) {
-      return;
-    }
-    this.client.trackMetric({ name, value });
-  }
-
-  static flush(): Promise<void> {
-    return new Promise((resolve) => {
-      if (!this.client) {
-        resolve();
-        return;
-      }
-      this.client.flush();
-      resolve();
-    });
-  }
-}

package/src/utils/UpdateCheckTracker.ts

@@ -1,86 +0,0 @@
-/**
- * Utility class to track update check operations in progress
- * Provides thread-safe access to check status with proper locking
- */
-export class UpdateCheckTracker {
-    private static instance: UpdateCheckTracker;
-
-    // Map to track operations in progress (key -> inProgress)
-    private operationsInProgress: Map<string, boolean> = new Map();
-
-    // Lock for thread safety when checking/updating the in-progress map
-    private operationsLock: Promise<void> = Promise.resolve();
-
-    private constructor() { }
-
-    /**
-     * Get the singleton instance of the tracker
-     */
-    public static getInstance(): UpdateCheckTracker {
-        if (!UpdateCheckTracker.instance) {
-            UpdateCheckTracker.instance = new UpdateCheckTracker();
-        }
-        return UpdateCheckTracker.instance;
-    }
-
-    /**
-     * Execute an operation with a lock to ensure thread safety
-     * @param operation The operation to execute
-     * @returns The result of the operation
-     * @private
-     */
-    private async withLock<T>(operation: () => Promise<T>): Promise<T> {
-        const current = this.operationsLock;
-        let resolve: () => void;
-        this.operationsLock = new Promise<void>(r => resolve = r);
-        try {
-            await current;
-            return await operation();
-        } finally {
-            resolve!();
-        }
-    }
-
-    /**
-     * Check if an operation can be started and mark it as in progress if so
-     * @param key The key to identify the operation
-     * @returns True if the operation can be started, false if already in progress
-     */
-    async startOperation(key: string): Promise<boolean> {
-        return await this.withLock(async () => {
-            if (!this.operationsInProgress.get(key)) {
-                this.operationsInProgress.set(key, true);
-                return true;
-            }
-            return false;
-        });
-    }
-
-    /**
-     * Mark an operation as complete
-     * @param key The key to identify the operation
-     */
-    async endOperation(key: string): Promise<void> {
-        try {
-            await this.withLock(async () => {
-                this.operationsInProgress.set(key, false);
-            });
-        } catch (error) {
-            console.error(`Failed to end operation for key: ${key}`, error);
-        }
-    }
-
-    /**
-     * Check if an operation is in progress
-     * @param key The key to identify the operation
-     * @returns True if the operation is in progress
-     */
-    async isOperationInProgress(key: string): Promise<boolean> {
-        return await this.withLock(async () => {
-            return !!this.operationsInProgress.get(key);
-        });
-    }
-}
-
-// Export a singleton instance
-export const updateCheckTracker = UpdateCheckTracker.getInstance();

package/src/utils/adoUtils.ts

@@ -1,293 +0,0 @@
-import { RequirementConfig, RegistryConfig } from '../core/metadatas/types.js';
-import { SETTINGS_DIR } from '../core/metadatas/constants.js';
-import { Logger } from './logger.js';
-import { exec, execSync } from 'child_process';
-import util from 'util';
-import fs from 'fs/promises';
-import path from 'path';
-import { isToolInstalled } from './osUtils.js'; // Assuming this can be adapted or a similar check is fine
-
-const execAsync = util.promisify(exec);
-
-export interface AdoArtifactResult {
-    type: 'npm' | 'pip';
-    package: string;
-    registryUrl: string;
-    folderPath?: string; // Only for npm
-    version: string;
-}
-
-/**
- * Sets up the NPM credential provider.
- * Installs @microsoft/artifacts-npm-credprovider if not already installed.
- * @private
- */
-async function _setupNpmCredentialProvider(): Promise<void> {
-    Logger.debug('Setting up NPM credential provider...');
-    const credProviderCommand = 'artifacts-npm-credprovider';
-
-    // Check if artifacts-npm-credprovider is installed by trying to get its version or a known command.
-    // A more robust check might involve checking a specific version or path.
-    let installed = false;
-    try {
-        // Attempt to get help output as a basic check for presence
-        const { stdout, stderr } = await execAsync(`${credProviderCommand} --help`);
-        Logger.debug(`${credProviderCommand} --help stdout: ${stdout}`);
-        if (stderr) Logger.debug(`${credProviderCommand} --help stderr: ${stderr}`);
-        installed = true;
-        Logger.debug(`${credProviderCommand} appears to be installed.`);
-    } catch (e) {
-        Logger.debug(`${credProviderCommand} not found or --help failed, attempting installation. Error: ${e}`);
-    }
-
-    if (!installed) {
-        Logger.log(`Installing @microsoft/artifacts-npm-credprovider...`);
-        try {
-            const installCommand = `npm install -g @microsoft/artifacts-npm-credprovider --registry https://pkgs.dev.azure.com/mseng/226da8e7-b1c0-4167-9678-53f461e07706/_packaging/AzureArtifacts/npm/registry/`;
-            const { stdout: installStdout, stderr: installStderr } = await execAsync(installCommand);
-            Logger.debug(`@microsoft/artifacts-npm-credprovider install stdout: ${installStdout}`);
-            if (installStderr) Logger.debug(`@microsoft/artifacts-npm-credprovider install stderr: ${installStderr}`);
-            Logger.log('@microsoft/artifacts-npm-credprovider installed successfully.');
-        } catch (error) {
-            Logger.error('Failed to install @microsoft/artifacts-npm-credprovider', error);
-            throw new Error(`Failed to install @microsoft/artifacts-npm-credprovider: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-}
-
-/**
- * Installs pip requirements: keyring and artifacts-keyring.
- * @param pythonCommand The python command to use (e.g., 'python' or 'python3').
- * @private
- */
-async function _installPipRequirements(pythonCommand: string): Promise<void> {
-    Logger.debug(`Installing pip requirements: keyring, artifacts-keyring using ${pythonCommand}`);
-    try {
-        const command = `${pythonCommand} -m pip install keyring artifacts-keyring`;
-        const { stdout, stderr } = await execAsync(command);
-        Logger.debug(`pip install keyring artifacts-keyring stdout: ${stdout}`);
-        if (stderr) Logger.debug(`pip install keyring artifacts-keyring stderr: ${stderr}`);
-        Logger.log('Successfully installed keyring and artifacts-keyring.');
-    } catch (error) {
-        Logger.error('Failed to install pip requirements (keyring, artifacts-keyring)', error);
-        throw new Error(`Failed to install pip requirements: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-
-/**
- * Configures NPM authentication for Azure DevOps Artifacts in a specified directory.
- * This includes setting up the credential provider, creating an .npmrc file,
- * and running the credential provider.
- * @param execPromise The promise-based exec function.
- * @param registry The Azure DevOps artifacts registry configuration.
- * @param directoryPath The directory where .npmrc will be created and commands will be executed.
- * @private
- */
-async function _configureNpmAdoAuthInDirectory(
-    execPromise: (command: string, options?: { cwd?: string; env?: NodeJS.ProcessEnv }) => Promise<{ stdout: string; stderr: string }>,
-    registry: RegistryConfig['artifacts'],
-    directoryPath: string
-): Promise<void> {
-    if (!registry || !registry.registryUrl || !registry.registryName) {
-        throw new Error('Registry name and URL are required for NPM ADO auth configuration.');
-    }
-
-    await _setupNpmCredentialProvider();
-
-    const npmrcContent = `@${registry.registryName}:registry=${registry.registryUrl}\nalways-auth=true`;
-    const npmrcPath = path.join(directoryPath, '.npmrc');
-    await fs.writeFile(npmrcPath, npmrcContent.trim());
-    Logger.debug(`Created/Updated .npmrc file at: ${npmrcPath}`);
-
-    const env = { ...process.env, NUGET_CREDENTIALPROVIDER_VSTS_TOKENTYPE: 'SelfDescribing' };
-    Logger.debug(`Running artifacts-npm-credprovider in ${directoryPath}`);
-    const { stdout: credProviderStdout, stderr: credProviderStderr } = await execPromise('artifacts-npm-credprovider', { cwd: directoryPath, env });
-    Logger.debug(`artifacts-npm-credprovider stdout: ${credProviderStdout}`);
-    if (credProviderStderr) Logger.debug(`artifacts-npm-credprovider stderr: ${credProviderStderr}`);
-    Logger.log(`Successfully ran artifacts-npm-credprovider in ${directoryPath}`);
-}
-
-/**
- * Handles fetching and setting up an Azure DevOps artifact.
- * @param requirement The requirement configuration.
- * @param registry The Azure DevOps artifacts registry configuration.
- * @param pythonCommand Optional Python command (e.g., 'python', 'python3') for pip operations.
- * @param targetDir Optional target directory for npm artifact setup. If not provided, a default will be used.
- * @returns A promise that resolves with the artifact details.
- */
-export async function handleArtifact(
-    requirement: RequirementConfig,
-    registry: RegistryConfig['artifacts'],
-    pythonCommand: string = 'python', // Default to 'python' if not provided
-    targetDir?: string // Optional target directory for npm
-): Promise<AdoArtifactResult> {
-    if (!registry) {
-        throw new Error('Azure DevOps artifacts registry configuration is required.');
-    }
-    Logger.debug(`Handling ADO artifact for requirement: ${requirement.name}, type: ${requirement.type}`);
-
-    if (requirement.type === 'npm') {
-        if (!registry.registryName || !registry.registryUrl) {
-            throw new Error('Registry name and URL are required for NPM source in Azure DevOps artifacts.');
-        }
-        const requirementDir = targetDir || path.join(SETTINGS_DIR, 'requirements', requirement.name, requirement.version);
-        await fs.mkdir(requirementDir, { recursive: true });
-        Logger.debug(`Ensured directory for npm requirement: ${requirementDir}`);
-
-        try {
-            await _configureNpmAdoAuthInDirectory(execAsync, registry, requirementDir);
-            Logger.log(`Successfully configured ADO NPM auth for ${requirement.name} in ${requirementDir}`);
-
-            const version = requirement.version.includes('latest') ? 'latest' : requirement.version;
-            return {
-                folderPath: requirementDir,
-                type: 'npm',
-                package: `@${registry.registryName}/${requirement.name}`,
-                registryUrl: registry.registryUrl,
-                version: version
-            };
-        } catch (error) {
-            Logger.error(`Failed to configure ADO NPM auth for ${requirement.name} in ${requirementDir}`, error);
-            throw new Error(`ADO NPM auth configuration failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-
-    } else if (requirement.type === 'pip') {
-        if (!registry.registryUrl) {
-            throw new Error('Registry URL are required for PIP source in Azure DevOps artifacts.');
-        }
-        await _installPipRequirements(pythonCommand);
-
-        const packageName = requirement.version.toLowerCase().includes('latest')
-            ? `${requirement.name} --upgrade`
-            : `${requirement.name}==${requirement.version}`;
-
-        Logger.log(`Pip requirement ${packageName} configured with registry ${registry.registryUrl}`);
-        return {
-            type: 'pip',
-            package: packageName,
-            registryUrl: registry.registryUrl,
-            version: requirement.version
-        };
-    } else {
-        throw new Error(`Unsupported requirement type for ADO artifact: ${requirement.type}`);
-    }
-}
-
-/**
- * Get the latest version of an artifact from Azure DevOps.
- * This is a simplified implementation and might require further enhancements for robust authentication and error handling.
- * @param execPromise The promise-based exec function.
- * @param requirement The requirement configuration.
- * @param registry The Azure DevOps artifacts registry configuration.
- * @param options Optional server install options (e.g., for pythonCommand).
- * @returns The latest version string, or undefined if not found or an error occurs.
- */
-export async function getArtifactLatestVersion(
-    requirement: RequirementConfig,
-    registry: RegistryConfig['artifacts'],
-    options?: import('../core/metadatas/types.js').ServerInstallOptions, // Added import for ServerInstallOptions
-    targetDir?: string // Optional target directory for npm
-): Promise<string | undefined> {
-    if (!registry || !registry.registryUrl) {
-        Logger.error('ADO Artifact registry URL is missing for fetching latest version.');
-        return undefined;
-    }
-
-    Logger.debug(`Attempting to fetch latest version for ADO artifact: ${requirement.name} of type ${requirement.type}`);
-
-    if (requirement.type === 'npm') {
-        if (!registry.registryName) { // Ensure registryName is present
-            Logger.error('NPM ADO Artifact registry name is missing for fetching latest version.');
-            return undefined;
-        }
-
-        const requirementDir = targetDir || path.join(SETTINGS_DIR, 'requirements', requirement.name, requirement.version);
-
-        try {
-            await fs.mkdir(requirementDir, { recursive: true });
-            Logger.debug(`Ensured directory for NPM ADO version check: ${requirementDir}`);
-
-            // Configure auth within the requirementDir
-            await _configureNpmAdoAuthInDirectory(execAsync, registry, requirementDir);
-            Logger.log(`Successfully configured ADO NPM auth for version check of ${requirement.name} in ${requirementDir}`);
-
-            const fullPackageName = `@${registry.registryName}/${requirement.name}`;
-            const command = `npm view ${fullPackageName} version --registry ${registry.registryUrl}`;
-            Logger.debug(`Executing for NPM ADO latest version: ${command} in ${requirementDir}`);
-
-            const { stdout, stderr } = await execAsync(command, { cwd: requirementDir });
-
-            if (stderr && !stdout.trim()) {
-                Logger.error(`Error fetching NPM ADO version for ${fullPackageName} via npm view: ${stderr}`);
-                return undefined;
-            }
-
-            const version = stdout.trim();
-            if (version) {
-                Logger.debug(`Found latest NPM ADO version for ${fullPackageName}: ${version}`);
-                return version;
-            } else {
-                Logger.log(`Could not parse latest NPM version from ADO for ${fullPackageName} from output: '${stdout}'`);
-                return undefined;
-            }
-        } catch (error) {
-            Logger.error(`Exception fetching latest NPM version from ADO for ${requirement.name} in ${requirementDir}: ${error instanceof Error ? error.message : String(error)}`);
-            return undefined;
-        }
-    } else if (requirement.type === 'pip') {
-        try {
-            const pythonCmd = options?.settings?.pythonEnv as string || 'python';
-            const pipCmd = `${pythonCmd} -m pip`;
-
-            // Ensure keyring and artifacts-keyring are installed.
-            // This is usually handled by `handleArtifact` during install.
-            // For a standalone version check, we might need to ensure they exist.
-            // Consider calling _installPipRequirements(pythonCmd) if necessary, but it has side effects.
-            // For now, assume they are present if ADO pip artifacts are being used.
-
-            const command = `${pipCmd} index versions ${requirement.name} --extra-index-url ${registry.registryUrl}`;
-            Logger.debug(`Executing for Pip ADO latest version: ${command}`);
-            const { stdout, stderr } = await execAsync(command);
-
-            if (stderr && !stdout.trim()) { // If there's stderr and no significant stdout, it's likely an error
-                Logger.error(`Error fetching Pip ADO version for ${requirement.name}: ${stderr}`);
-                return undefined;
-            }
-
-            // Parse output like:
-            // mypackage (1.0.0)
-            // Available versions: 1.0.0, 0.9.0
-            // LATEST:          1.0.0
-            // Or:
-            // mypackage
-            // VERSIONS: 1.0.0, 0.9.0
-            // Latest: 1.0.0
-            const latestMatch = stdout.match(/(?:LATEST|Latest):\s*([^\s]+)/);
-            if (latestMatch && latestMatch[1]) {
-                Logger.debug(`Found latest Pip ADO version via LATEST line: ${latestMatch[1]}`);
-                return latestMatch[1];
-            }
-
-            // Fallback: try to parse from "Available versions" or "VERSIONS"
-            const versionsMatch = stdout.match(/(?:Available versions|VERSIONS):\s*([^\n]+)/);
-            if (versionsMatch && versionsMatch[1]) {
-                const versions = versionsMatch[1].split(',').map(v => v.trim()).filter(v => v);
-                if (versions.length > 0) {
-                    // This is a naive approach, assumes the first listed is relevant or latest.
-                    // Proper sorting (e.g. semver) would be better.
-                    Logger.debug(`Found Pip ADO versions: ${versions.join(', ')}. Taking the first one: ${versions[0]}`);
-                    return versions[0];
-                }
-            }
-
-            Logger.log(`Could not parse latest Pip version from ADO for ${requirement.name} from output: ${stdout}`); // Changed Logger.warn to Logger.log
-            return undefined;
-        } catch (error) {
-            Logger.error(`Exception fetching latest Pip version from ADO for ${requirement.name}: ${error instanceof Error ? error.message : String(error)}`);
-            return undefined;
-        }
-    }
-
-    Logger.log(`getArtifactLatestVersion not implemented for type '${requirement.type}' or encountered an issue.`); // Changed Logger.warn to Logger.log
-    return undefined;
-}

package/src/utils/clientUtils.ts

@@ -1,72 +0,0 @@
-import fs from 'fs/promises';
-import * as path from 'path';
-import extractZipModule from 'extract-zip';
-
-/**
- * Extract a zip file to a directory
- * @param zipPath The path to the zip file
- * @param options Extraction options
- * @returns A promise that resolves when extraction is complete
- */
-export async function extractZipFile(zipPath: string, options: { dir: string }): Promise<void> {
-    try {
-        // Try to use extract-zip if available
-        if (typeof extractZipModule === 'function') {
-            return await extractZipModule(zipPath, options);
-        }
-
-        // Fallback to Node.js built-in unzipper
-        const fs = require('fs');
-        const unzipper = require('unzipper');
-
-        await fs.promises.mkdir(options.dir, { recursive: true });
-
-        return new Promise<void>((resolve, reject) => {
-            fs.createReadStream(zipPath)
-                .pipe(unzipper.Extract({ path: options.dir }))
-                .on('close', resolve)
-                .on('error', reject);
-        });
-    } catch (error) {
-        console.error(`Error extracting zip: ${error instanceof Error ? error.message : String(error)}`);
-        throw new Error(`Failed to extract zip file ${zipPath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}
-
-
-/**
- * Reads a JSON file and parses its content
- * @param filePath Path to the JSON file
- * @param createIfNotExist Whether to create the file if it doesn't exist
- * @returns The parsed JSON content
- */
-import stripJsonComments from 'strip-json-comments';
-
-export async function readJsonFile(filePath: string, createIfNotExist = false): Promise<any> {
-    try {
-        // Ensure directory exists
-        if (createIfNotExist) {
-            await fs.mkdir(path.dirname(filePath), { recursive: true });
-        }
-
-        const content = await fs.readFile(filePath, 'utf8');
-        // Remove comments and trailing commas from JSON content
-        const sanitizedContent = stripJsonComments(content).replace(/,(\s*[}\]])/g, '$1');
-        return JSON.parse(sanitizedContent);
-    } catch (error) {
-        if ((error as NodeJS.ErrnoException).code === 'ENOENT' && createIfNotExist) {
-            return {};
-        }
-        throw error;
-    }
-}
-
-/**
- * Writes content to a JSON file
- * @param filePath Path to the JSON file
- * @param content Content to write to the file
- */
-export async function writeJsonFile(filePath: string, content: any): Promise<void> {
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.writeFile(filePath, JSON.stringify(content, null, 2), 'utf8');
-}