@imenam/self-register-proxy 1.0.46 → 1.0.48

package/meta-config.js

@@ -1,336 +1,336 @@
-/**
- * MetaConfigManager - Gestion des méta-configurations pour le proxy
- * 
- * Permet de grouper les configurations de plusieurs MCPs en un seul profil
- * applicable en un clic depuis le dashboard.
- * 
- * Persistence : meta-configs.json dans le répertoire du proxy (__dirname)
- */
-
-const fs = require('fs');
-const path = require('path');
-
-// Détermine le dossier de configuration
-// Utilise PROXY_CONFIG_DIR si défini, sinon le dossier courant (__dirname)
-const configDir = process.env.PROXY_CONFIG_DIR 
-  ? path.resolve(__dirname, process.env.PROXY_CONFIG_DIR) 
-  : __dirname;
-
-// Création du dossier s'il n'existe pas
-if (!fs.existsSync(configDir)) {
-  try {
-    fs.mkdirSync(configDir, { recursive: true });
-  } catch (err) {
-    console.error(`[META-CONFIG] Erreur lors de la création du dossier ${configDir}:`, err.message);
-  }
-}
-
-const META_CONFIGS_FILE = path.join(configDir, 'meta-configs.json');
-
-const DISCOVERY_TIMEOUT = 3000; // 3s timeout per MCP
-
-/**
- * Structure du fichier meta-configs.json :
- * {
- *   "metaConfigs": {
- *     "<id>": {
- *       "name": "string",
- *       "description": "string",
- *       "mappings": { "<mcpPath>": "<configId>", ... },
- *       "createdAt": "ISO8601"
- *     }
- *   },
- *   "activeMetaConfig": "<id>" | null
- * }
- */
-
-/**
- * Charge les méta-configurations depuis le fichier JSON
- * @returns {{ metaConfigs: Object, activeMetaConfig: string|null }}
- */
-function loadMetaConfigs() {
-  try {
-    if (fs.existsSync(META_CONFIGS_FILE)) {
-      const raw = fs.readFileSync(META_CONFIGS_FILE, 'utf-8');
-      return JSON.parse(raw);
-    }
-  } catch (err) {
-    console.error('[META-CONFIG] Error loading meta-configs:', err.message);
-  }
-  return { metaConfigs: {}, activeMetaConfig: null };
-}
-
-/**
- * Sauvegarde les méta-configurations dans le fichier JSON
- * @param {{ metaConfigs: Object, activeMetaConfig: string|null }} data
- */
-function saveMetaConfigs(data) {
-  try {
-    fs.writeFileSync(META_CONFIGS_FILE, JSON.stringify(data, null, 2), 'utf-8');
-  } catch (err) {
-    console.error('[META-CONFIG] Error saving meta-configs:', err.message);
-    throw err;
-  }
-}
-
-/**
- * Retourne toutes les méta-configurations
- * @returns {{ metaConfigs: Object, activeMetaConfig: string|null }}
- */
-function getAll() {
-  return loadMetaConfigs();
-}
-
-/**
- * Retourne une méta-configuration par son ID
- * @param {string} id
- * @returns {Object|null}
- */
-function getById(id) {
-  const data = loadMetaConfigs();
-  return data.metaConfigs[id] || null;
-}
-
-/**
- * Crée une nouvelle méta-configuration
- * @param {string} id - Identifiant unique (slug)
- * @param {string} name - Nom affiché
- * @param {string} description - Description
- * @param {Object} mappings - { mcpPath: configId, ... }
- * @returns {Object} La méta-configuration créée
- */
-function create(id, name, description, mappings) {
-  const data = loadMetaConfigs();
-
-  if (data.metaConfigs[id]) {
-    throw new Error(`Meta-config "${id}" already exists`);
-  }
-
-  data.metaConfigs[id] = {
-    name,
-    description: description || '',
-    mappings: mappings || {},
-    createdAt: new Date().toISOString()
-  };
-
-  saveMetaConfigs(data);
-  return data.metaConfigs[id];
-}
-
-/**
- * Met à jour partiellement une méta-configuration
- * @param {string} id
- * @param {Object} updates - Champs à mettre à jour (name, description, mappings)
- * @returns {Object} La méta-configuration mise à jour
- */
-function update(id, updates) {
-  const data = loadMetaConfigs();
-
-  if (!data.metaConfigs[id]) {
-    throw new Error(`Meta-config "${id}" not found`);
-  }
-
-  const config = data.metaConfigs[id];
-  if (updates.name !== undefined) config.name = updates.name;
-  if (updates.description !== undefined) config.description = updates.description;
-  if (updates.mappings !== undefined) config.mappings = updates.mappings;
-
-  saveMetaConfigs(data);
-  return config;
-}
-
-/**
- * Supprime une méta-configuration
- * @param {string} id
- */
-function remove(id) {
-  const data = loadMetaConfigs();
-
-  if (!data.metaConfigs[id]) {
-    throw new Error(`Meta-config "${id}" not found`);
-  }
-
-  delete data.metaConfigs[id];
-
-  if (data.activeMetaConfig === id) {
-    data.activeMetaConfig = null;
-  }
-
-  saveMetaConfigs(data);
-}
-
-/**
- * Définit la méta-configuration active
- * @param {string|null} id
- */
-function setActive(id) {
-  const data = loadMetaConfigs();
-
-  if (id !== null && !data.metaConfigs[id]) {
-    throw new Error(`Meta-config "${id}" not found`);
-  }
-
-  data.activeMetaConfig = id;
-  saveMetaConfigs(data);
-}
-
-/**
- * Retourne l'ID de la méta-configuration active
- * @returns {string|null}
- */
-function getActive() {
-  const data = loadMetaConfigs();
-  return data.activeMetaConfig;
-}
-
-/**
- * Découvre les configurations disponibles auprès de tous les MCPs enregistrés
- * Interroge GET /api/configurations sur chaque MCP via son target direct
- * 
- * @param {Map} routes - Le registry.routes du proxy
- * @returns {Promise<Array<{ path: string, name: string, configurations: Array|null, error: string|null }>>}
- */
-async function discoverConfigurations(routes) {
-  const results = [];
-
-  const promises = [];
-  for (const [mcpPath, route] of routes.entries()) {
-    const target = route.target || 'http://localhost';
-    const url = `${target}:${route.port}/api/configurations`;
-
-    promises.push(
-      (async () => {
-        try {
-          const controller = new AbortController();
-          const timeoutId = setTimeout(() => controller.abort(), DISCOVERY_TIMEOUT);
-
-          const response = await fetch(url, {
-            method: 'GET',
-            signal: controller.signal
-          });
-
-          clearTimeout(timeoutId);
-
-          if (response.status === 200) {
-            const data = await response.json();
-            return {
-              path: mcpPath,
-              name: route.name,
-              configurations: data.configurations || [],
-              error: null
-            };
-          }
-
-          return {
-            path: mcpPath,
-            name: route.name,
-            configurations: null,
-            error: `HTTP ${response.status}`
-          };
-        } catch (err) {
-          return {
-            path: mcpPath,
-            name: route.name,
-            configurations: null,
-            error: err.name === 'AbortError' ? 'timeout' : err.message
-          };
-        }
-      })()
-    );
-  }
-
-  const settled = await Promise.all(promises);
-  results.push(...settled);
-
-  return results;
-}
-
-/**
- * Applique une méta-configuration : envoie POST /api/configurations/apply à chaque MCP
- * 
- * @param {string} metaConfigId - ID de la méta-configuration à appliquer
- * @param {Map} routes - Le registry.routes du proxy
- * @returns {Promise<{ success: boolean, results: Array<{ path: string, success: boolean, error?: string }> }>}
- */
-async function applyMetaConfig(metaConfigId, routes) {
-  const config = getById(metaConfigId);
-  if (!config) {
-    throw new Error(`Meta-config "${metaConfigId}" not found`);
-  }
-
-  const missingResults = [];
-  const promises = [];
-
-  for (const [mcpPath, configId] of Object.entries(config.mappings)) {
-    const route = routes.get(mcpPath);
-    if (!route) {
-      missingResults.push({
-        path: mcpPath,
-        success: false,
-        error: 'MCP not registered'
-      });
-      continue;
-    }
-
-    const target = route.target || 'http://localhost';
-    const url = `${target}:${route.port}/api/configurations/apply`;
-
-    promises.push(
-      (async () => {
-        try {
-          const controller = new AbortController();
-          const timeoutId = setTimeout(() => controller.abort(), DISCOVERY_TIMEOUT);
-
-          const response = await fetch(url, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ configId }),
-            signal: controller.signal
-          });
-
-          clearTimeout(timeoutId);
-
-          if (response.ok) {
-            const data = await response.json();
-            return { path: mcpPath, success: true, appliedConfig: data.appliedConfig || configId };
-          }
-
-          const errorData = await response.json().catch(() => ({}));
-          return { path: mcpPath, success: false, error: errorData.error || `HTTP ${response.status}` };
-        } catch (err) {
-          return {
-            path: mcpPath,
-            success: false,
-            error: err.name === 'AbortError' ? 'timeout' : err.message
-          };
-        }
-      })()
-    );
-  }
-
-  const settled = await Promise.all(promises);
-
-  const allAppliedSuccess = settled.length === 0 || settled.every(r => r.success);
-
-  if (allAppliedSuccess) {
-    setActive(metaConfigId);
-  }
-
-  return {
-    success: allAppliedSuccess,
-    warnings: missingResults,
-    results: [...missingResults, ...settled]
-  };
-}
-
-module.exports = {
-  getAll,
-  getById,
-  create,
-  update,
-  remove,
-  setActive,
-  getActive,
-  discoverConfigurations,
-  applyMetaConfig
-};
+/**
+ * MetaConfigManager - Gestion des méta-configurations pour le proxy
+ * 
+ * Permet de grouper les configurations de plusieurs MCPs en un seul profil
+ * applicable en un clic depuis le dashboard.
+ * 
+ * Persistence : meta-configs.json dans le répertoire du proxy (__dirname)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Détermine le dossier de configuration
+// Utilise PROXY_CONFIG_DIR si défini, sinon le dossier courant (__dirname)
+const configDir = process.env.PROXY_CONFIG_DIR 
+  ? path.resolve(__dirname, process.env.PROXY_CONFIG_DIR) 
+  : __dirname;
+
+// Création du dossier s'il n'existe pas
+if (!fs.existsSync(configDir)) {
+  try {
+    fs.mkdirSync(configDir, { recursive: true });
+  } catch (err) {
+    console.error(`[META-CONFIG] Erreur lors de la création du dossier ${configDir}:`, err.message);
+  }
+}
+
+const META_CONFIGS_FILE = path.join(configDir, 'meta-configs.json');
+
+const DISCOVERY_TIMEOUT = 3000; // 3s timeout per MCP
+
+/**
+ * Structure du fichier meta-configs.json :
+ * {
+ *   "metaConfigs": {
+ *     "<id>": {
+ *       "name": "string",
+ *       "description": "string",
+ *       "mappings": { "<mcpPath>": "<configId>", ... },
+ *       "createdAt": "ISO8601"
+ *     }
+ *   },
+ *   "activeMetaConfig": "<id>" | null
+ * }
+ */
+
+/**
+ * Charge les méta-configurations depuis le fichier JSON
+ * @returns {{ metaConfigs: Object, activeMetaConfig: string|null }}
+ */
+function loadMetaConfigs() {
+  try {
+    if (fs.existsSync(META_CONFIGS_FILE)) {
+      const raw = fs.readFileSync(META_CONFIGS_FILE, 'utf-8');
+      return JSON.parse(raw);
+    }
+  } catch (err) {
+    console.error('[META-CONFIG] Error loading meta-configs:', err.message);
+  }
+  return { metaConfigs: {}, activeMetaConfig: null };
+}
+
+/**
+ * Sauvegarde les méta-configurations dans le fichier JSON
+ * @param {{ metaConfigs: Object, activeMetaConfig: string|null }} data
+ */
+function saveMetaConfigs(data) {
+  try {
+    fs.writeFileSync(META_CONFIGS_FILE, JSON.stringify(data, null, 2), 'utf-8');
+  } catch (err) {
+    console.error('[META-CONFIG] Error saving meta-configs:', err.message);
+    throw err;
+  }
+}
+
+/**
+ * Retourne toutes les méta-configurations
+ * @returns {{ metaConfigs: Object, activeMetaConfig: string|null }}
+ */
+function getAll() {
+  return loadMetaConfigs();
+}
+
+/**
+ * Retourne une méta-configuration par son ID
+ * @param {string} id
+ * @returns {Object|null}
+ */
+function getById(id) {
+  const data = loadMetaConfigs();
+  return data.metaConfigs[id] || null;
+}
+
+/**
+ * Crée une nouvelle méta-configuration
+ * @param {string} id - Identifiant unique (slug)
+ * @param {string} name - Nom affiché
+ * @param {string} description - Description
+ * @param {Object} mappings - { mcpPath: configId, ... }
+ * @returns {Object} La méta-configuration créée
+ */
+function create(id, name, description, mappings) {
+  const data = loadMetaConfigs();
+
+  if (data.metaConfigs[id]) {
+    throw new Error(`Meta-config "${id}" already exists`);
+  }
+
+  data.metaConfigs[id] = {
+    name,
+    description: description || '',
+    mappings: mappings || {},
+    createdAt: new Date().toISOString()
+  };
+
+  saveMetaConfigs(data);
+  return data.metaConfigs[id];
+}
+
+/**
+ * Met à jour partiellement une méta-configuration
+ * @param {string} id
+ * @param {Object} updates - Champs à mettre à jour (name, description, mappings)
+ * @returns {Object} La méta-configuration mise à jour
+ */
+function update(id, updates) {
+  const data = loadMetaConfigs();
+
+  if (!data.metaConfigs[id]) {
+    throw new Error(`Meta-config "${id}" not found`);
+  }
+
+  const config = data.metaConfigs[id];
+  if (updates.name !== undefined) config.name = updates.name;
+  if (updates.description !== undefined) config.description = updates.description;
+  if (updates.mappings !== undefined) config.mappings = updates.mappings;
+
+  saveMetaConfigs(data);
+  return config;
+}
+
+/**
+ * Supprime une méta-configuration
+ * @param {string} id
+ */
+function remove(id) {
+  const data = loadMetaConfigs();
+
+  if (!data.metaConfigs[id]) {
+    throw new Error(`Meta-config "${id}" not found`);
+  }
+
+  delete data.metaConfigs[id];
+
+  if (data.activeMetaConfig === id) {
+    data.activeMetaConfig = null;
+  }
+
+  saveMetaConfigs(data);
+}
+
+/**
+ * Définit la méta-configuration active
+ * @param {string|null} id
+ */
+function setActive(id) {
+  const data = loadMetaConfigs();
+
+  if (id !== null && !data.metaConfigs[id]) {
+    throw new Error(`Meta-config "${id}" not found`);
+  }
+
+  data.activeMetaConfig = id;
+  saveMetaConfigs(data);
+}
+
+/**
+ * Retourne l'ID de la méta-configuration active
+ * @returns {string|null}
+ */
+function getActive() {
+  const data = loadMetaConfigs();
+  return data.activeMetaConfig;
+}
+
+/**
+ * Découvre les configurations disponibles auprès de tous les MCPs enregistrés
+ * Interroge GET /api/configurations sur chaque MCP via son target direct
+ * 
+ * @param {Map} routes - Le registry.routes du proxy
+ * @returns {Promise<Array<{ path: string, name: string, configurations: Array|null, error: string|null }>>}
+ */
+async function discoverConfigurations(routes) {
+  const results = [];
+
+  const promises = [];
+  for (const [mcpPath, route] of routes.entries()) {
+    const target = route.target || 'http://localhost';
+    const url = `${target}:${route.port}/api/configurations`;
+
+    promises.push(
+      (async () => {
+        try {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), DISCOVERY_TIMEOUT);
+
+          const response = await fetch(url, {
+            method: 'GET',
+            signal: controller.signal
+          });
+
+          clearTimeout(timeoutId);
+
+          if (response.status === 200) {
+            const data = await response.json();
+            return {
+              path: mcpPath,
+              name: route.name,
+              configurations: data.configurations || [],
+              error: null
+            };
+          }
+
+          return {
+            path: mcpPath,
+            name: route.name,
+            configurations: null,
+            error: `HTTP ${response.status}`
+          };
+        } catch (err) {
+          return {
+            path: mcpPath,
+            name: route.name,
+            configurations: null,
+            error: err.name === 'AbortError' ? 'timeout' : err.message
+          };
+        }
+      })()
+    );
+  }
+
+  const settled = await Promise.all(promises);
+  results.push(...settled);
+
+  return results;
+}
+
+/**
+ * Applique une méta-configuration : envoie POST /api/configurations/apply à chaque MCP
+ * 
+ * @param {string} metaConfigId - ID de la méta-configuration à appliquer
+ * @param {Map} routes - Le registry.routes du proxy
+ * @returns {Promise<{ success: boolean, results: Array<{ path: string, success: boolean, error?: string }> }>}
+ */
+async function applyMetaConfig(metaConfigId, routes) {
+  const config = getById(metaConfigId);
+  if (!config) {
+    throw new Error(`Meta-config "${metaConfigId}" not found`);
+  }
+
+  const missingResults = [];
+  const promises = [];
+
+  for (const [mcpPath, configId] of Object.entries(config.mappings)) {
+    const route = routes.get(mcpPath);
+    if (!route) {
+      missingResults.push({
+        path: mcpPath,
+        success: false,
+        error: 'MCP not registered'
+      });
+      continue;
+    }
+
+    const target = route.target || 'http://localhost';
+    const url = `${target}:${route.port}/api/configurations/apply`;
+
+    promises.push(
+      (async () => {
+        try {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), DISCOVERY_TIMEOUT);
+
+          const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ configId }),
+            signal: controller.signal
+          });
+
+          clearTimeout(timeoutId);
+
+          if (response.ok) {
+            const data = await response.json();
+            return { path: mcpPath, success: true, appliedConfig: data.appliedConfig || configId };
+          }
+
+          const errorData = await response.json().catch(() => ({}));
+          return { path: mcpPath, success: false, error: errorData.error || `HTTP ${response.status}` };
+        } catch (err) {
+          return {
+            path: mcpPath,
+            success: false,
+            error: err.name === 'AbortError' ? 'timeout' : err.message
+          };
+        }
+      })()
+    );
+  }
+
+  const settled = await Promise.all(promises);
+
+  const allAppliedSuccess = settled.length === 0 || settled.every(r => r.success);
+
+  if (allAppliedSuccess) {
+    setActive(metaConfigId);
+  }
+
+  return {
+    success: allAppliedSuccess,
+    warnings: missingResults,
+    results: [...missingResults, ...settled]
+  };
+}
+
+module.exports = {
+  getAll,
+  getById,
+  create,
+  update,
+  remove,
+  setActive,
+  getActive,
+  discoverConfigurations,
+  applyMetaConfig
+};