imcp 0.0.16 → 0.0.18

package/dist/core/loaders/ConfigurationProvider.js

@@ -0,0 +1,384 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { fileURLToPath } from 'url';
+import { GITHUB_REPO, LOCAL_FEEDS_DIR, SETTINGS_DIR, SUPPORTED_CLIENTS } from '../metadatas/constants.js';
+import { Logger } from '../../utils/logger.js';
+import { checkGithubAuth } from '../../utils/githubAuth.js';
+import { ConfigurationLoader } from './ConfigurationLoader.js';
+const execAsync = promisify(exec);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export class ConfigurationProvider {
+    static instance;
+    configPath;
+    configuration;
+    configLock = Promise.resolve();
+    tempDir;
+    constructor() {
+        // Initialize configuration in user's appdata/imcp directory
+        this.configPath = path.join(SETTINGS_DIR, 'configurations.json');
+        this.configuration = {
+            localServerCategories: [],
+            feeds: {},
+            clientMCPSettings: {}
+        };
+        this.tempDir = path.join(LOCAL_FEEDS_DIR, '../temp');
+    }
+    static getInstance() {
+        if (!ConfigurationProvider.instance) {
+            ConfigurationProvider.instance = new ConfigurationProvider();
+        }
+        return ConfigurationProvider.instance;
+    }
+    async withLock(operation) {
+        const current = this.configLock;
+        let resolve;
+        this.configLock = new Promise(r => resolve = r);
+        try {
+            await current;
+            return await operation();
+        }
+        finally {
+            resolve();
+        }
+    }
+    async initialize(feedFile, settings) {
+        await this.withLock(async () => {
+            const configDir = path.dirname(this.configPath);
+            await fs.mkdir(configDir, { recursive: true });
+            // remove the old configuration file if it exists
+            try {
+                await fs.rm(this.configPath, { recursive: true, force: true });
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    throw error;
+                }
+            }
+            try {
+                try {
+                    const config = JSON.parse(await fs.readFile(this.configPath, 'utf8'));
+                    this.configuration = config;
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT') {
+                        throw error;
+                    }
+                    // File doesn't exist, use default empty configuration
+                    await this.saveConfiguration();
+                }
+                // Always load feeds and client settings, whether file existed or not
+                await this.loadFeedsIntoConfiguration(feedFile, settings);
+                await this.loadClientMCPSettings();
+            }
+            catch (error) {
+                Logger.error('Error during initialization', error);
+                throw error;
+            }
+        });
+    }
+    async saveConfiguration() {
+        const configDir = path.dirname(this.configPath);
+        await fs.mkdir(configDir, { recursive: true });
+        await fs.writeFile(this.configPath, JSON.stringify(this.configuration, null, 2));
+    }
+    async getServerCategories() {
+        return await this.withLock(async () => {
+            return this.configuration.localServerCategories;
+        });
+    }
+    async getServerCategory(categoryName) {
+        return await this.withLock(async () => {
+            return this.configuration.localServerCategories.find(s => s.name === categoryName);
+        });
+    }
+    async getClientMcpSettings() {
+        return await this.withLock(async () => {
+            return this.configuration.clientMCPSettings;
+        });
+    }
+    async getFeedConfiguration(categoryName) {
+        return await this.withLock(async () => {
+            return this.configuration.feeds[categoryName];
+        });
+    }
+    async getServerMcpConfig(categoryName, serverName) {
+        return await this.withLock(async () => {
+            return this.configuration.feeds[categoryName]?.mcpServers.find(s => s.name === serverName);
+        });
+    }
+    async getInstallationStatus(categoryName) {
+        return await this.withLock(async () => {
+            // Inline getServerCategory logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            return category?.installationStatus;
+        });
+    }
+    async getServerStatus(categoryName, serverName) {
+        return await this.withLock(async () => {
+            // Inline getInstallationStatus logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            const status = category?.installationStatus;
+            return status?.serversStatus[serverName];
+        });
+    }
+    async getRequirementStatus(categoryName, requirementName) {
+        return await this.withLock(async () => {
+            // Inline getInstallationStatus logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            const status = category?.installationStatus;
+            return status?.requirementsStatus[requirementName];
+        });
+    }
+    async updateInstallationStatus(categoryName, requirementStatus, serverStatus) {
+        return await this.withLock(async () => {
+            // Inline getServerCategory logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            if (!category)
+                return false;
+            if (!category.installationStatus) {
+                category.installationStatus = {
+                    requirementsStatus: {},
+                    serversStatus: {},
+                    lastUpdated: new Date().toISOString()
+                };
+            }
+            category.installationStatus.requirementsStatus = {
+                ...category.installationStatus.requirementsStatus,
+                ...requirementStatus
+            };
+            category.installationStatus.serversStatus = {
+                ...category.installationStatus.serversStatus,
+                ...serverStatus
+            };
+            category.installationStatus.lastUpdated = new Date().toISOString();
+            await this.saveConfiguration();
+            return true;
+        });
+    }
+    async updateRequirementStatus(categoryName, requirementName, status) {
+        return await this.withLock(async () => {
+            // Inline getServerCategory logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            if (!category?.installationStatus)
+                return false;
+            category.installationStatus.requirementsStatus[requirementName] = status;
+            category.installationStatus.lastUpdated = new Date().toISOString();
+            await this.saveConfiguration();
+            return true;
+        });
+    }
+    async updateRequirementOperationStatus(categoryName, requirementName, operationStatus) {
+        return await this.withLock(async () => {
+            // Inline getServerCategory logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            if (!category?.installationStatus?.requirementsStatus[requirementName])
+                return false;
+            category.installationStatus.requirementsStatus[requirementName].operationStatus = operationStatus;
+            category.installationStatus.lastUpdated = new Date().toISOString();
+            await this.saveConfiguration();
+            return true;
+        });
+    }
+    async updateServerStatus(categoryName, serverName, status) {
+        return await this.withLock(async () => {
+            // Inline getServerCategory logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            if (!category?.installationStatus)
+                return false;
+            category.installationStatus.serversStatus[serverName] = status;
+            category.installationStatus.lastUpdated = new Date().toISOString();
+            await this.saveConfiguration();
+            return true;
+        });
+    }
+    async updateServerOperationStatus(categoryName, serverName, clientName, operationStatus) {
+        return await this.withLock(async () => {
+            // Inline getServerCategory logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            if (!category?.installationStatus?.serversStatus[serverName])
+                return false;
+            category.installationStatus.serversStatus[serverName].installedStatus[clientName] = operationStatus;
+            category.installationStatus.lastUpdated = new Date().toISOString();
+            await this.saveConfiguration();
+            return true;
+        });
+    }
+    async isRequirementsReady(categoryName, serverName) {
+        return await this.withLock(async () => {
+            // Inline getServerCategory logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            if (!category?.feedConfiguration)
+                return false;
+            const serverConfig = category.feedConfiguration.mcpServers.find(s => s.name === serverName);
+            if (!serverConfig?.dependencies?.requirements)
+                return true; // No requirements means ready
+            const requirementNames = serverConfig.dependencies.requirements.map(r => r.name);
+            // Inline getInstallationStatus logic (using the already fetched category)
+            const status = category?.installationStatus;
+            if (!status?.requirementsStatus)
+                return false;
+            return requirementNames.every(name => {
+                const reqStatus = status.requirementsStatus[name];
+                return reqStatus?.installed && !reqStatus?.error;
+            });
+        });
+    }
+    async GetServerRequirementStatus(categoryName, serverName) {
+        return await this.withLock(async () => {
+            // Inline getServerCategory logic
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            if (!category?.feedConfiguration)
+                return [];
+            const serverConfig = category.feedConfiguration.mcpServers.find(s => s.name === serverName);
+            if (!serverConfig?.dependencies?.requirements)
+                return [];
+            const requirementNames = serverConfig.dependencies.requirements.map(r => r.name);
+            return requirementNames
+                .map(name => category?.installationStatus?.requirementsStatus[name])
+                .filter(x => x !== undefined);
+        });
+    }
+    async isServerReady(categoryName, serverName, clients) {
+        return await this.withLock(async () => {
+            // Inline the logic from getServerStatus and getInstallationStatus to avoid nested lock
+            const category = this.configuration.localServerCategories.find(s => s.name === categoryName);
+            const installationStatus = category?.installationStatus;
+            const serverStatus = installationStatus?.serversStatus[serverName];
+            if (!serverStatus)
+                return false;
+            return clients.every(clientName => {
+                // Add optional chaining for safety in case installedStatus is missing
+                const clientStatus = serverStatus.installedStatus?.[clientName];
+                return clientStatus?.status === 'completed' && !clientStatus?.error;
+            });
+        });
+    }
+    async syncFeeds() {
+        return await this.withLock(async () => {
+            Logger.log('Starting feed synchronization...');
+            try {
+                // Check GitHub authentication first
+                await checkGithubAuth();
+                Logger.debug({
+                    action: 'create_directories',
+                    paths: {
+                        localFeeds: LOCAL_FEEDS_DIR,
+                        tempDir: this.tempDir
+                    }
+                });
+                await fs.mkdir(LOCAL_FEEDS_DIR, { recursive: true });
+                await fs.mkdir(this.tempDir, { recursive: true });
+                // Clean up temp directory
+                await fs.rm(this.tempDir, { recursive: true, force: true });
+                // Download latest release
+                Logger.debug('Downloading latest release...');
+                const { downloadGithubRelease } = await import('../../utils/githubUtils.js');
+                const { version, downloadPath } = await downloadGithubRelease(GITHUB_REPO.repoName, 'latest', GITHUB_REPO.feedAssetsName, undefined, true, this.tempDir);
+                Logger.debug({
+                    action: 'download_release',
+                    downloadPath,
+                    version,
+                    repoName: GITHUB_REPO.repoName,
+                });
+                Logger.debug('Updating local feeds...');
+                await fs.rm(LOCAL_FEEDS_DIR, { recursive: true, force: true });
+                const sourceFeedsDir = downloadPath;
+                try {
+                    await fs.access(downloadPath);
+                }
+                catch (err) {
+                    throw new Error(`Could not find feeds directory in downloaded path: ${sourceFeedsDir}`);
+                }
+                await fs.cp(sourceFeedsDir, LOCAL_FEEDS_DIR, { recursive: true, force: true });
+                Logger.log('Successfully updated local feeds');
+            }
+            catch (error) {
+                Logger.error('Error during feed synchronization', error);
+                throw new Error('Failed to sync feeds. Use --verbose for detailed error information.');
+            }
+        });
+    }
+    async loadFeedsIntoConfiguration(feedFile, settings) {
+        this.configuration = await ConfigurationLoader.loadFeedsIntoConfiguration(this.configuration, feedFile, settings);
+        await this.saveConfiguration();
+    }
+    async loadClientMCPSettings() {
+        this.configuration = await ConfigurationLoader.loadClientMCPSettings(this.configuration);
+        await this.saveConfiguration();
+    }
+    // Public method to reload client MCP settings
+    async reloadClientMCPSettings() {
+        return await this.withLock(async () => {
+            await this.loadClientMCPSettings();
+        });
+    }
+    async removeServerFromClientMCPSettings(serverName, target) {
+        return await this.withLock(async () => {
+            // Load utils in async context to avoid circular dependencies
+            const { readJsonFile, writeJsonFile } = await import('../../utils/clientUtils.js');
+            // Filter clients if target is specified
+            const clientEntries = Object.entries(SUPPORTED_CLIENTS);
+            const targetClients = target
+                ? clientEntries.filter(([clientName]) => clientName === target)
+                : clientEntries;
+            for (const [clientName, clientSettings] of targetClients) {
+                const settingPath = process.env.CODE_INSIDERS
+                    ? clientSettings.codeInsiderSettingPath
+                    : clientSettings.codeSettingPath;
+                try {
+                    const content = await readJsonFile(settingPath, true);
+                    let modified = false;
+                    // Handle GitHub Copilot's different structure
+                    if (clientName === 'GithubCopilot' && content.mcp?.servers?.[serverName]) {
+                        delete content.mcp.servers[serverName];
+                        modified = true;
+                    }
+                    else if (content.mcpServers?.[serverName]) {
+                        delete content.mcpServers[serverName];
+                        modified = true;
+                    }
+                    // Only write if we actually modified the content
+                    if (modified) {
+                        await writeJsonFile(settingPath, content);
+                        Logger.debug(`Removed server ${serverName} from client ${clientName} settings`);
+                    }
+                }
+                catch (error) {
+                    Logger.error(`Failed to remove server ${serverName} from client ${clientName} settings:`, error);
+                }
+            }
+            // Also update our in-memory configuration
+            if (this.configuration.clientMCPSettings) {
+                if (target) {
+                    // Only update settings for the target client
+                    const clientSettings = this.configuration.clientMCPSettings[target];
+                    if (clientSettings) {
+                        if (clientSettings.mcpServers?.[serverName]) {
+                            delete clientSettings.mcpServers[serverName];
+                        }
+                        if (clientSettings.servers?.[serverName]) { // For GitHub Copilot
+                            delete clientSettings.servers[serverName];
+                        }
+                    }
+                }
+                else {
+                    // Update all clients if no target specified
+                    for (const clientSettings of Object.values(this.configuration.clientMCPSettings)) {
+                        if (clientSettings.mcpServers?.[serverName]) {
+                            delete clientSettings.mcpServers[serverName];
+                        }
+                        if (clientSettings.servers?.[serverName]) { // For GitHub Copilot
+                            delete clientSettings.servers[serverName];
+                        }
+                    }
+                }
+                await this.saveConfiguration();
+            }
+        });
+    }
+}
+// Export a singleton instance
+export const configProvider = ConfigurationProvider.getInstance();
+//# sourceMappingURL=ConfigurationProvider.js.map

package/dist/core/loaders/ServerSchemaLoader.d.ts

@@ -0,0 +1,22 @@
+import { ServerSchema } from './ServerSchemaProvider.js';
+export declare class ServerSchemaLoader {
+    /**
+     * Loads a single schema file.
+     * @param filePath The absolute path to the schema file.
+     * @returns A Promise that resolves to the ServerSchema or undefined if not found or error.
+     */
+    static loadSchema(filePath: string): Promise<ServerSchema | undefined>;
+    /**
+     * Loads all schemas from the default feeds directory.
+     * @param defaultFeedsDir The path to the default feeds directory.
+     * @param schemaMap The map to populate with loaded schemas.
+     */
+    static loadAllDefaultSchemas(defaultFeedsDir: string, schemaMap: Map<string, Map<string, ServerSchema>>): Promise<void>;
+    /**
+     * Loads schemas from an adhoc directory for a specific category.
+     * @param adhocSchemasDir The path to the adhoc schemas directory.
+     * @param categoryName The name of the category for these adhoc schemas.
+     * @param schemaMap The map to update with loaded adhoc schemas.
+     */
+    static loadAdhocSchemas(adhocSchemasDir: string, categoryName: string, schemaMap: Map<string, Map<string, ServerSchema>>): Promise<void>;
+}

package/dist/core/loaders/ServerSchemaLoader.js

@@ -0,0 +1,109 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { Logger } from '../../utils/logger.js';
+export class ServerSchemaLoader {
+    /**
+     * Loads a single schema file.
+     * @param filePath The absolute path to the schema file.
+     * @returns A Promise that resolves to the ServerSchema or undefined if not found or error.
+     */
+    static async loadSchema(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf8');
+            const schema = JSON.parse(content);
+            return {
+                schema: schema
+            };
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                Logger.debug(`No schema file found at ${filePath}`);
+                return undefined;
+            }
+            Logger.error(`Error loading schema from ${filePath}:`, error);
+            // Optionally rethrow or return undefined based on desired error handling
+            return undefined;
+        }
+    }
+    /**
+     * Loads all schemas from the default feeds directory.
+     * @param defaultFeedsDir The path to the default feeds directory.
+     * @param schemaMap The map to populate with loaded schemas.
+     */
+    static async loadAllDefaultSchemas(defaultFeedsDir, schemaMap) {
+        schemaMap.clear(); // Clear map for initial load from default directory
+        try {
+            const categoryDirs = await fs.readdir(defaultFeedsDir, { withFileTypes: true });
+            for (const categoryDir of categoryDirs) {
+                if (categoryDir.isDirectory()) {
+                    const categoryName = categoryDir.name;
+                    const categoryPath = path.join(defaultFeedsDir, categoryName);
+                    const serverFiles = await fs.readdir(categoryPath);
+                    const serverSchemas = new Map();
+                    for (const file of serverFiles) {
+                        if (file.endsWith('.json')) {
+                            try {
+                                const schemaFilePath = path.join(categoryPath, file);
+                                const schema = await this.loadSchema(schemaFilePath);
+                                if (schema) {
+                                    serverSchemas.set(file, schema); // file is serverName
+                                    Logger.debug(`Loaded schema '${file}' for category '${categoryName}' from default directory`);
+                                }
+                            }
+                            catch (error) { // Error already logged in loadSchema
+                                Logger.error(`Skipping schema file ${file} in category ${categoryName} due to loading error.`);
+                            }
+                        }
+                    }
+                    if (serverSchemas.size > 0) {
+                        schemaMap.set(categoryName, serverSchemas);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            Logger.error(`Error reading schemas from default directory ${defaultFeedsDir}:`, error);
+        }
+    }
+    /**
+     * Loads schemas from an adhoc directory for a specific category.
+     * @param adhocSchemasDir The path to the adhoc schemas directory.
+     * @param categoryName The name of the category for these adhoc schemas.
+     * @param schemaMap The map to update with loaded adhoc schemas.
+     */
+    static async loadAdhocSchemas(adhocSchemasDir, categoryName, schemaMap) {
+        try {
+            const serverFiles = await fs.readdir(adhocSchemasDir);
+            if (schemaMap.has(categoryName)) {
+                Logger.warn(`\x1b[33mAdhoc schema category '${categoryName}' (from dir: ${adhocSchemasDir}) conflicts with an existing category. Adhoc schemas in this category will override existing ones.\x1b[0m`);
+            }
+            let serverSchemas = schemaMap.get(categoryName);
+            if (!serverSchemas) {
+                serverSchemas = new Map();
+            }
+            for (const file of serverFiles) {
+                if (file.endsWith('.json')) {
+                    try {
+                        const schemaFilePath = path.join(adhocSchemasDir, file);
+                        const schema = await this.loadSchema(schemaFilePath);
+                        if (schema) {
+                            serverSchemas.set(file, schema); // file is serverName
+                            Logger.debug(`Loaded adhoc schema '${file}' for category '${categoryName}'`);
+                        }
+                    }
+                    catch (error) { // Error already logged in loadSchema
+                        Logger.error(`Skipping adhoc schema file ${file} in category ${categoryName} due to loading error.`);
+                    }
+                }
+            }
+            if (serverSchemas.size > 0) {
+                schemaMap.set(categoryName, serverSchemas);
+            }
+        }
+        catch (error) {
+            // This case should ideally be caught by the fs.access check in ServerSchemaProvider.initialize
+            Logger.error(`Error reading adhoc schemas from directory ${adhocSchemasDir} for category ${categoryName}:`, error);
+        }
+    }
+}
+//# sourceMappingURL=ServerSchemaLoader.js.map

package/dist/core/loaders/ServerSchemaProvider.d.ts

@@ -0,0 +1,14 @@
+export interface ServerSchema {
+    schema: Record<string, any>;
+}
+export declare class ServerSchemaProvider {
+    private static instance;
+    private schemaMap;
+    private schemaLock;
+    private constructor();
+    static getInstance(): ServerSchemaProvider;
+    private withLock;
+    initialize(adhocSchemasDir?: string): Promise<void>;
+    getSchema(categoryName: string, schemaFileName: string): Promise<ServerSchema | undefined>;
+    reloadSchemas(): Promise<void>;
+}

package/dist/core/loaders/ServerSchemaProvider.js

@@ -0,0 +1,90 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { LOCAL_FEEDS_SCHEMA_DIR } from '../metadatas/constants.js';
+import { Logger } from '../../utils/logger.js';
+import { ServerSchemaLoader } from './ServerSchemaLoader.js';
+export class ServerSchemaProvider {
+    static instance;
+    schemaMap;
+    schemaLock = Promise.resolve();
+    constructor() {
+        this.schemaMap = new Map();
+    }
+    static getInstance() {
+        if (!ServerSchemaProvider.instance) {
+            ServerSchemaProvider.instance = new ServerSchemaProvider();
+            // Initialize is now called with optional adhocSchemasDir,
+            // but getInstance is often called without it initially.
+            // The actual loading with adhoc dir will happen when MCPManager calls initialize.
+        }
+        return ServerSchemaProvider.instance;
+    }
+    async withLock(operation) {
+        const current = this.schemaLock;
+        let resolve;
+        this.schemaLock = new Promise(r => resolve = r);
+        try {
+            await current;
+            return await operation();
+        }
+        finally {
+            resolve();
+        }
+    }
+    async initialize(adhocSchemasDir) {
+        await this.withLock(async () => {
+            try {
+                // Create default feeds directory if it doesn't exist
+                await fs.mkdir(LOCAL_FEEDS_SCHEMA_DIR, { recursive: true });
+                // Load all schemas from the default feeds directory
+                await ServerSchemaLoader.loadAllDefaultSchemas(LOCAL_FEEDS_SCHEMA_DIR, this.schemaMap);
+                // Load schemas from adhoc directory if provided
+                if (adhocSchemasDir) {
+                    try {
+                        await fs.access(adhocSchemasDir); // Check if directory exists
+                        const adhocCategoryName = path.basename(adhocSchemasDir);
+                        Logger.info(`Loading adhoc schemas from: ${adhocSchemasDir} for category: ${adhocCategoryName}`);
+                        await ServerSchemaLoader.loadAdhocSchemas(adhocSchemasDir, adhocCategoryName, this.schemaMap);
+                    }
+                    catch (error) {
+                        if (error.code === 'ENOENT') {
+                            Logger.warn(`Adhoc schemas directory not found: ${adhocSchemasDir}`);
+                        }
+                        else {
+                            Logger.error(`Error accessing adhoc schemas directory ${adhocSchemasDir}:`, error);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                Logger.error('Error during schema initialization:', error);
+                throw error;
+            }
+        });
+    }
+    // The actual loading methods (loadSchema, loadAllSchemas, loadAdhocSchemas) have been moved to ServerSchemaLoader.
+    // ServerSchemaProvider now delegates to ServerSchemaLoader for these operations.
+    async getSchema(categoryName, schemaFileName) {
+        return await this.withLock(async () => {
+            const categorySchemas = this.schemaMap.get(categoryName);
+            if (!categorySchemas) {
+                Logger.debug(`No schemas found for category ${categoryName}`);
+                return undefined;
+            }
+            const schema = categorySchemas.get(schemaFileName);
+            if (!schema) {
+                Logger.debug(`Schema ${schemaFileName} not found in category ${categoryName}`);
+            }
+            return schema;
+        });
+    }
+    async reloadSchemas() {
+        return await this.withLock(async () => {
+            // Reloading should re-evaluate both default and any configured adhoc directory
+            // For simplicity, we assume initialize would be called again if adhoc path changes.
+            // This reload will just reload from the paths known during the last full initialize.
+            await this.initialize(); // This will re-load default and adhoc if adhocSchemasDir was set
+        });
+    }
+}
+//# sourceMappingURL=ServerSchemaProvider.js.map

package/dist/core/metadatas/constants.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Defines constants used across the application.
+ */
+/**
+ * GitHub repository configuration for feeds
+ */
+export declare const GITHUB_REPO: {
+    url: string;
+    repoName: string;
+    feedsPath: string;
+    feedAssetsName: string;
+};
+/**
+ * Local settings directory path based on OS
+ */
+export declare const SETTINGS_DIR: string;
+/**
+ * Local feeds directory path
+ */
+export declare const LOCAL_FEEDS_DIR: string;
+export declare const LOCAL_FEEDS_SCHEMA_DIR: string;
+/**
+ * Supported client configurations.
+ * Key: Client name (e.g., 'vscode')
+ * Value: Client-specific settings or configuration details.
+ * TODO: Define actual client settings structure.
+ */
+export declare const SUPPORTED_CLIENTS: Record<string, {
+    extension: {
+        extensionId: string;
+        leastVersion?: string;
+        repository?: string;
+        assetName?: string;
+        private?: boolean;
+    };
+    codeSettingPath: string;
+    codeInsiderSettingPath: string;
+}>;
+/**
+ * List of supported client names.
+ */
+export declare const SUPPORTED_CLIENT_NAMES: string[];
+/**
+ * Minimum time between requirement update checks (in milliseconds)
+ * 10 minutes = 10 * 60 * 1000 = 600000 ms
+ */
+export declare const UPDATE_CHECK_INTERVAL_MS: number;