coding-tool-x 3.7.0 → 3.7.1

package/src/server/services/{pi-settings-manager.js → omp-settings-manager.js}

@@ -2,10 +2,13 @@ const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const yaml = require('js-yaml');
-const piConfig = require('./pi-config');
+const ompConfig = require('./omp-config');
 
 const MANAGED_PROVIDER_PREFIX = 'ctx-';
 const MODELS_BACKUP_MARKER = '.ctx-backup-';
+const VISIBILITY_STATE_VERSION = 1;
+const MANAGED_VISIBILITY_STATE_FILE = 'coding-tool-x-omp-managed-visibility.json';
+const NO_MANAGED_MODELS_SELECTOR = `${MANAGED_PROVIDER_PREFIX}coding-tool-x/__no_models_configured__`;
 const THINKING_EFFORT_LEVELS = ['minimal', 'low', 'medium', 'high', 'xhigh'];
 const THINKING_MODES = new Set([
   'effort',
@@ -17,12 +20,12 @@ const THINKING_MODES = new Set([
 
 let lastManagedOmpSyncResult = null;
 
-function getPiPaths(...args) {
-  return piConfig.getPiPaths(...args);
+function getOmpPaths(...args) {
+  return ompConfig.getOmpPaths(...args);
 }
 
-function ensurePiDir(...args) {
-  return piConfig.ensurePiDir(...args);
+function ensureOmpDir(...args) {
+  return ompConfig.ensureOmpDir(...args);
 }
 
 function normalizeProviderId(value = '') {
@@ -144,6 +147,41 @@ function compactObject(value = {}) {
   return next;
 }
 
+function uniqueStrings(values = []) {
+  const seen = new Set();
+  const result = [];
+  (Array.isArray(values) ? values : []).forEach((value) => {
+    const item = String(value || '').trim();
+    if (!item || seen.has(item)) return;
+    seen.add(item);
+    result.push(item);
+  });
+  return result;
+}
+
+function pushUnique(values, value) {
+  const item = String(value || '').trim();
+  if (item && !values.includes(item)) {
+    values.push(item);
+  }
+}
+
+function sameStringSet(left = [], right = []) {
+  const leftSet = new Set(uniqueStrings(left));
+  const rightSet = new Set(uniqueStrings(right));
+  if (leftSet.size !== rightSet.size) return false;
+  for (const item of leftSet) {
+    if (!rightSet.has(item)) return false;
+  }
+  return true;
+}
+
+function getOwnProperty(object, key) {
+  return object && typeof object === 'object' && !Array.isArray(object)
+    ? Object.prototype.hasOwnProperty.call(object, key)
+    : false;
+}
+
 function mergeDefined(base = {}, override = {}) {
   const next = { ...base };
   Object.entries(override || {}).forEach(([key, value]) => {
@@ -233,8 +271,8 @@ function readOmpCatalogModels(command, providerId, options = {}) {
 
 function buildCatalogIndex(channel = {}, options = {}) {
   const runtime = options.runtime
-    || (typeof piConfig.resolvePiRuntime === 'function'
-      ? piConfig.resolvePiRuntime(options.env || process.env, options.runtimeOptions || {})
+    || (typeof ompConfig.resolveOmpRuntime === 'function'
+      ? ompConfig.resolveOmpRuntime(options.env || process.env, options.runtimeOptions || {})
       : null);
   if (!runtime || runtime.runtime !== 'omp' || !runtime.installed) {
     return new Map();
@@ -278,7 +316,7 @@ function buildProviderEntry(channel = {}, options = {}) {
   return entry;
 }
 
-function readModelsConfig(filePath = getPiPaths().modelsYml) {
+function readModelsConfig(filePath = getOmpPaths().modelsYml) {
   try {
     if (!fs.existsSync(filePath)) {
       return { providers: {} };
@@ -300,8 +338,8 @@ function readModelsConfig(filePath = getPiPaths().modelsYml) {
   }
 }
 
-function writeModelsConfig(config, filePath = getPiPaths().modelsYml) {
-  ensurePiDir(path.dirname(filePath));
+function writeModelsConfig(config, filePath = getOmpPaths().modelsYml) {
+  ensureOmpDir(path.dirname(filePath));
   const doc = yaml.dump(config || { providers: {} }, {
     lineWidth: 120,
     noRefs: true,
@@ -310,6 +348,44 @@ function writeModelsConfig(config, filePath = getPiPaths().modelsYml) {
   fs.writeFileSync(filePath, doc, 'utf8');
 }
 
+function getOmpSettingsPath(paths = getOmpPaths()) {
+  if (paths.settings || paths.config) {
+    return paths.settings || paths.config;
+  }
+  const baseDir = paths.agentDir
+    || path.dirname(paths.modelsYml || paths.models || process.cwd());
+  return path.join(baseDir, 'config.yml');
+}
+
+function readOmpSettingsConfig(filePath = getOmpSettingsPath()) {
+  try {
+    if (!filePath || !fs.existsSync(filePath)) {
+      return {};
+    }
+    const raw = fs.readFileSync(filePath, 'utf8');
+    if (!raw.trim()) {
+      return {};
+    }
+    const parsed = yaml.load(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return {};
+    }
+    return parsed;
+  } catch (error) {
+    throw new Error(`Failed to read OMP config.yml: ${error.message}`);
+  }
+}
+
+function writeOmpSettingsConfig(config, filePath = getOmpSettingsPath()) {
+  ensureOmpDir(path.dirname(filePath));
+  const doc = yaml.dump(config || {}, {
+    lineWidth: 120,
+    noRefs: true,
+    sortKeys: false
+  });
+  fs.writeFileSync(filePath, doc, 'utf8');
+}
+
 function getModelsBackupPrefix(filePath) {
   return `${path.basename(filePath)}${MODELS_BACKUP_MARKER}`;
 }
@@ -343,6 +419,44 @@ function createModelsBackupIfNeeded(filePath, options = {}) {
   return backupPath;
 }
 
+function getManagedVisibilityStatePath(paths = getOmpPaths()) {
+  if (paths.managedVisibilityState) {
+    return paths.managedVisibilityState;
+  }
+  const baseDir = paths.agentDir
+    || path.dirname(paths.settings || paths.config || paths.modelsYml || paths.models || process.cwd());
+  return path.join(baseDir, MANAGED_VISIBILITY_STATE_FILE);
+}
+
+function readManagedVisibilityState(paths = getOmpPaths()) {
+  const filePath = getManagedVisibilityStatePath(paths);
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const raw = fs.readFileSync(filePath, 'utf8');
+    if (!raw.trim()) return null;
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeManagedVisibilityState(state, paths = getOmpPaths()) {
+  const filePath = getManagedVisibilityStatePath(paths);
+  ensureOmpDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+  return filePath;
+}
+
+function removeManagedVisibilityState(paths = getOmpPaths()) {
+  const filePath = getManagedVisibilityStatePath(paths);
+  if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+    return true;
+  }
+  return false;
+}
+
 function normalizeCommandOutput(value) {
   if (value === undefined || value === null) return '';
   return Buffer.isBuffer(value) ? value.toString('utf8') : String(value);
@@ -393,11 +507,32 @@ function runModelsJson(command, env, options = {}) {
   return result || { status: 0, stdout: '', stderr: '' };
 }
 
+function collectVisibleProviderIds(command, env, options = {}) {
+  const runner = options.visibilityModelsRunner || options.modelsRunner || spawnSync;
+  const result = runner(command, ['models', '--json'], {
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      ...env
+    },
+    timeout: options.visibilityTimeout || options.timeout || 5000
+  });
+  const status = result?.status === undefined || result?.status === null ? 0 : result.status;
+  if (result?.error || status !== 0) return [];
+  try {
+    const parsed = JSON.parse(normalizeCommandOutput(result?.stdout).trim() || '{}');
+    const models = Array.isArray(parsed.models) ? parsed.models : [];
+    return uniqueStrings(models.map(model => model?.provider));
+  } catch {
+    return [];
+  }
+}
+
 function validateOmpModelsConfig(options = {}) {
   const env = options.env || process.env;
   const runtime = options.runtime
-    || (typeof piConfig.resolvePiRuntime === 'function'
-      ? piConfig.resolvePiRuntime(env, options.runtimeOptions || {})
+    || (typeof ompConfig.resolveOmpRuntime === 'function'
+      ? ompConfig.resolveOmpRuntime(env, options.runtimeOptions || {})
       : null);
 
   if (!runtime || runtime.runtime !== 'omp' || !runtime.installed) {
@@ -455,7 +590,7 @@ function getLastManagedOmpSyncResult() {
     : null;
 }
 
-function removeLegacyManagedExtension(paths = getPiPaths()) {
+function removeLegacyManagedExtension(paths = getOmpPaths()) {
   const target = paths.managedProviderExtension;
   if (target && fs.existsSync(target)) {
     fs.unlinkSync(target);
@@ -488,27 +623,287 @@ function buildManagedModelsConfig(channels = [], baseConfig = readModelsConfig()
   return next;
 }
 
+function getOriginalProviderId(channel = {}) {
+  const providerId = normalizeProviderId(channel.providerKey || channel.provider || channel.name || channel.id);
+  return isManagedProviderId(providerId)
+    ? providerId.slice(MANAGED_PROVIDER_PREFIX.length)
+    : providerId;
+}
+
+function collectManagedVisibility(channels = [], modelsConfig = { providers: {} }, options = {}) {
+  const managedEnabledModels = [];
+  const managedDisabledProviders = [];
+  const warnings = [];
+  const providers = modelsConfig.providers || {};
+
+  (channels || [])
+    .filter(channel => channel && channel.enabled !== false && channel.baseUrl)
+    .forEach((channel) => {
+      const managedProviderId = getManagedProviderId(channel);
+      const providerEntry = providers[managedProviderId] || {};
+      const models = Array.isArray(providerEntry.models) ? providerEntry.models : [];
+      models.forEach((model) => {
+        const modelId = String(model?.id || model?.name || '').trim();
+        if (modelId) {
+          pushUnique(managedEnabledModels, `${managedProviderId}/${modelId}`);
+        }
+      });
+
+      const originalProviderId = getOriginalProviderId(channel);
+      if (originalProviderId && !isManagedProviderId(originalProviderId)) {
+        pushUnique(managedDisabledProviders, originalProviderId);
+      }
+      if (models.length === 0) {
+        warnings.push(`OMP channel "${channel.name || channel.id || managedProviderId}" has no configured models; OMP model scope will resolve to no usable managed models.`);
+      }
+    });
+
+  const env = options.env || process.env;
+  const runtime = options.runtime
+    || (typeof ompConfig.resolveOmpRuntime === 'function'
+      ? ompConfig.resolveOmpRuntime(env, options.runtimeOptions || {})
+      : null);
+  if (runtime && runtime.runtime === 'omp' && runtime.installed && options.discoverDisabledProviders !== false) {
+    collectVisibleProviderIds(runtime.command, env, options)
+      .filter(providerId => providerId && !isManagedProviderId(providerId))
+      .forEach(providerId => pushUnique(managedDisabledProviders, providerId));
+  }
+
+  return {
+    managedEnabledModels,
+    managedEnabledModelsForSettings: managedEnabledModels.length > 0
+      ? managedEnabledModels
+      : [NO_MANAGED_MODELS_SELECTOR],
+    managedDisabledProviders,
+    managedDefaultModel: managedEnabledModels[0] || null,
+    warnings
+  };
+}
+
+function captureOriginalVisibility(settings = {}) {
+  const modelRoles = settings.modelRoles && typeof settings.modelRoles === 'object' && !Array.isArray(settings.modelRoles)
+    ? settings.modelRoles
+    : {};
+  return {
+    enabledModels: getOwnProperty(settings, 'enabledModels') ? uniqueStrings(settings.enabledModels) : null,
+    disabledProviders: getOwnProperty(settings, 'disabledProviders') ? uniqueStrings(settings.disabledProviders) : null,
+    modelRolesHadDefault: getOwnProperty(modelRoles, 'default'),
+    modelRolesDefault: getOwnProperty(modelRoles, 'default') ? String(modelRoles.default || '') : null
+  };
+}
+
+function collectUserDisabledProviders(settings = {}, previousState = null) {
+  const currentDisabled = uniqueStrings(settings.disabledProviders);
+  if (!previousState?.active || !previousState.original) {
+    return currentDisabled;
+  }
+  const originalDisabled = Array.isArray(previousState.original.disabledProviders)
+    ? previousState.original.disabledProviders
+    : [];
+  const previousManagedDisabled = uniqueStrings(previousState.managedDisabledProviders);
+  const userAddedDuringManagedMode = currentDisabled
+    .filter(providerId => !previousManagedDisabled.includes(providerId) && !originalDisabled.includes(providerId));
+  return uniqueStrings([...originalDisabled, ...userAddedDuringManagedMode]);
+}
+
+function applyManagedModelRole(settings, visibility, previousState = null) {
+  const roles = settings.modelRoles && typeof settings.modelRoles === 'object' && !Array.isArray(settings.modelRoles)
+    ? { ...settings.modelRoles }
+    : {};
+  const currentDefault = String(roles.default || '').trim();
+  const previousManagedDefault = String(previousState?.managedDefaultModel || '').trim();
+  if (!visibility.managedDefaultModel) {
+    return roles;
+  }
+  const defaultIsManaged = visibility.managedEnabledModels.includes(currentDefault);
+  if (!currentDefault || !defaultIsManaged || currentDefault === previousManagedDefault) {
+    roles.default = visibility.managedDefaultModel;
+  }
+  return roles;
+}
+
+function syncManagedOmpVisibility(channels = [], modelsConfig = { providers: {} }, options = {}) {
+  const paths = getOmpPaths();
+  const settingsPath = getOmpSettingsPath(paths);
+  const statePath = getManagedVisibilityStatePath(paths);
+  const settings = readOmpSettingsConfig(settingsPath);
+  const previousState = readManagedVisibilityState(paths);
+  const visibility = collectManagedVisibility(channels, modelsConfig, options);
+  const original = previousState?.active && previousState.original
+    ? previousState.original
+    : captureOriginalVisibility(settings);
+  const before = JSON.stringify(settings);
+  const settingsBackupPath = createModelsBackupIfNeeded(settingsPath, options);
+
+  settings.enabledModels = visibility.managedEnabledModelsForSettings;
+  settings.disabledProviders = uniqueStrings([
+    ...collectUserDisabledProviders(settings, previousState),
+    ...visibility.managedDisabledProviders
+  ]);
+  settings.modelRoles = applyManagedModelRole(settings, visibility, previousState);
+
+  const after = JSON.stringify(settings);
+  if (before !== after) {
+    writeOmpSettingsConfig(settings, settingsPath);
+  }
+
+  const state = {
+    version: VISIBILITY_STATE_VERSION,
+    active: true,
+    settingsPath,
+    managedEnabledModels: visibility.managedEnabledModels,
+    managedEnabledModelsForSettings: visibility.managedEnabledModelsForSettings,
+    managedDisabledProviders: visibility.managedDisabledProviders,
+    managedDefaultModel: visibility.managedDefaultModel,
+    original,
+    updatedAt: new Date().toISOString()
+  };
+  writeManagedVisibilityState(state, paths);
+
+  return {
+    settingsPath,
+    statePath,
+    settingsBackupPath,
+    changed: before !== after,
+    managedEnabledModels: visibility.managedEnabledModels,
+    managedEnabledModelsForSettings: visibility.managedEnabledModelsForSettings,
+    managedDisabledProviders: visibility.managedDisabledProviders,
+    managedDefaultModel: visibility.managedDefaultModel,
+    warnings: visibility.warnings
+  };
+}
+
+function restoreOriginalList(settings, key, originalValue) {
+  if (Array.isArray(originalValue)) {
+    settings[key] = uniqueStrings(originalValue);
+    return;
+  }
+  delete settings[key];
+}
+
+function removeManagedOmpVisibility(options = {}) {
+  const paths = getOmpPaths();
+  const settingsPath = getOmpSettingsPath(paths);
+  const state = readManagedVisibilityState(paths);
+  const settings = readOmpSettingsConfig(settingsPath);
+  const before = JSON.stringify(settings);
+  const warnings = [];
+  let settingsBackupPath = null;
+
+  if (state?.active) {
+    settingsBackupPath = createModelsBackupIfNeeded(settingsPath, options);
+    const managedEnabled = uniqueStrings(state.managedEnabledModelsForSettings || state.managedEnabledModels);
+    const currentEnabled = uniqueStrings(settings.enabledModels);
+    if (sameStringSet(currentEnabled, managedEnabled)) {
+      restoreOriginalList(settings, 'enabledModels', state.original?.enabledModels);
+    } else if (managedEnabled.length > 0) {
+      const nextEnabled = currentEnabled.filter(model => !managedEnabled.includes(model));
+      if (nextEnabled.length > 0) {
+        settings.enabledModels = nextEnabled;
+      } else {
+        restoreOriginalList(settings, 'enabledModels', state.original?.enabledModels);
+      }
+      warnings.push('OMP enabledModels was changed while coding-tool-x managed visibility was active; preserved non-managed entries during cleanup.');
+    }
+
+    const managedDisabled = uniqueStrings(state.managedDisabledProviders);
+    const originalDisabled = Array.isArray(state.original?.disabledProviders)
+      ? state.original.disabledProviders
+      : [];
+    const currentDisabled = uniqueStrings(settings.disabledProviders);
+    const expectedDisabled = uniqueStrings([...originalDisabled, ...managedDisabled]);
+    if (sameStringSet(currentDisabled, expectedDisabled)) {
+      restoreOriginalList(settings, 'disabledProviders', state.original?.disabledProviders);
+    } else if (managedDisabled.length > 0) {
+      const nextDisabled = currentDisabled.filter(providerId => !managedDisabled.includes(providerId));
+      if (nextDisabled.length > 0) {
+        settings.disabledProviders = nextDisabled;
+      } else {
+        restoreOriginalList(settings, 'disabledProviders', state.original?.disabledProviders);
+      }
+      warnings.push('OMP disabledProviders was changed while coding-tool-x managed visibility was active; removed only managed provider entries.');
+    }
+
+    if (settings.modelRoles && typeof settings.modelRoles === 'object' && !Array.isArray(settings.modelRoles)) {
+      const roles = { ...settings.modelRoles };
+      if (roles.default === state.managedDefaultModel) {
+        if (state.original?.modelRolesHadDefault) {
+          roles.default = state.original.modelRolesDefault;
+        } else {
+          delete roles.default;
+        }
+        settings.modelRoles = roles;
+      }
+      if (Object.keys(settings.modelRoles).length === 0) {
+        delete settings.modelRoles;
+      }
+    }
+  } else {
+    const managedEnabled = uniqueStrings(settings.enabledModels)
+      .filter(model => isManagedProviderId(String(model).split('/')[0]));
+    if (managedEnabled.length > 0) {
+      settingsBackupPath = createModelsBackupIfNeeded(settingsPath, options);
+      settings.enabledModels = uniqueStrings(settings.enabledModels)
+        .filter(model => !managedEnabled.includes(model));
+      if (settings.enabledModels.length === 0) {
+        delete settings.enabledModels;
+      }
+      warnings.push('Removed stale coding-tool-x managed OMP enabledModels entries without a visibility state file.');
+    }
+  }
+
+  const after = JSON.stringify(settings);
+  if (before !== after) {
+    writeOmpSettingsConfig(settings, settingsPath);
+  }
+  const stateRemoved = removeManagedVisibilityState(paths);
+
+  return {
+    settingsPath,
+    statePath: getManagedVisibilityStatePath(paths),
+    settingsBackupPath,
+    changed: before !== after || stateRemoved,
+    stateRemoved,
+    warnings
+  };
+}
+
 function writeManagedOmpProviders(channels = [], options = {}) {
-  const paths = getPiPaths();
+  const paths = getOmpPaths();
   const config = buildManagedModelsConfig(channels, readModelsConfig(paths.modelsYml), options);
   const backupPath = createModelsBackupIfNeeded(paths.modelsYml, options);
   writeModelsConfig(config, paths.modelsYml);
+  const visibility = syncManagedOmpVisibility(channels, config, options);
   const validation = validateOmpModelsConfig(options);
+  const warnings = [
+    ...(visibility.warnings || []),
+    ...(validation.warnings || [])
+  ];
   recordManagedOmpSyncResult({
     path: paths.modelsYml,
     modelsPath: paths.modelsYml,
+    settingsPath: visibility.settingsPath,
+    statePath: visibility.statePath,
     backupPath,
+    modelsBackupPath: backupPath,
+    settingsBackupPath: visibility.settingsBackupPath,
     changed: true,
+    visibilityChanged: visibility.changed,
+    managedEnabledModels: visibility.managedEnabledModels,
+    managedEnabledModelsForSettings: visibility.managedEnabledModelsForSettings,
+    managedDisabledProviders: visibility.managedDisabledProviders,
+    managedDefaultModel: visibility.managedDefaultModel,
     validation,
-    warnings: validation.warnings || []
+    warnings
   });
   removeLegacyManagedExtension(paths);
   return paths.modelsYml;
 }
 
 function removeManagedOmpProviders(options = {}) {
-  const paths = getPiPaths();
+  const paths = getOmpPaths();
   const config = readModelsConfig(paths.modelsYml);
+  const visibility = removeManagedOmpVisibility(options);
   const before = Object.keys(config.providers || {}).length;
   pruneManagedProviders(config.providers);
   const after = Object.keys(config.providers || {}).length;
@@ -526,16 +921,25 @@ function removeManagedOmpProviders(options = {}) {
   recordManagedOmpSyncResult({
     path: paths.modelsYml,
     modelsPath: paths.modelsYml,
+    settingsPath: visibility.settingsPath,
+    statePath: visibility.statePath,
     backupPath,
+    modelsBackupPath: backupPath,
+    settingsBackupPath: visibility.settingsBackupPath,
     changed: before !== after,
+    visibilityChanged: visibility.changed,
+    stateRemoved: visibility.stateRemoved,
     validation,
-    warnings: validation.warnings || []
+    warnings: [
+      ...(visibility.warnings || []),
+      ...(validation.warnings || [])
+    ]
   });
   removeLegacyManagedExtension(paths);
 }
 
 function isManagedOmpProvidersActive() {
-  const paths = getPiPaths();
+  const paths = getOmpPaths();
   if (!fs.existsSync(paths.modelsYml)) {
     return false;
   }

package/src/server/services/{pi-statistics-service.js → omp-statistics-service.js}

@@ -6,7 +6,7 @@ const {
 } = require('./statistics-service');
 const { normalizeUsageTokens, toNumber } = require('./proxy-log-helper');
 
-const TOOL_TYPE = 'pi';
+const TOOL_TYPE = 'omp';
 
 function initAggregateEntry(name = '') {
   return {
@@ -174,7 +174,7 @@ function addSessionUsage(entry, session) {
 
 function readSessionUsage() {
   try {
-    const { getAllSessions } = require('./pi-sessions');
+    const { getAllSessions } = require('./omp-sessions');
     const sessions = getAllSessions();
     return Array.isArray(sessions) ? sessions : [];
   } catch {