coding-tool-x 3.7.10 → 3.7.12

package/src/server/omp-proxy-server.js

@@ -1,17 +1,97 @@
+const crypto = require('crypto');
 const { loadConfig } = require('../config/loader');
 const { saveProxyStartTime, clearProxyStartTime, getProxyStartTime, getProxyRuntime } = require('./services/proxy-runtime');
-const { syncManagedOmpProviders, disableManagedOmpProviders, getEnabledChannels } = require('./services/omp-channels');
+const {
+  syncManagedOmpProviders,
+  disableManagedOmpProviders,
+  activateStaticOmpChannel,
+  getEnabledChannels,
+  isManagedOmpModeEnabled,
+  enableManagedOmpMode,
+  disableManagedOmpMode,
+  loadManagedOmpActiveChannelId,
+  loadManagedOmpModeState
+} = require('./services/omp-channels');
+const {
+  startOmpSessionLogObserver,
+  stopOmpSessionLogObserver,
+  getOmpSessionLogObserverStatus
+} = require('./services/omp-session-log-observer');
+const { createOmpGateway } = require('./services/omp-gateway');
+const { prepareManagedOmpChannels } = require('./services/omp-gateway-routing');
+const { probeOmpAuthGateways } = require('./services/omp-auth-gateway-client');
 
-let running = false;
 let currentPort = null;
 let lastSyncResult = null;
+let lastRoutingResult = { routes: [], unsupportedChannels: [] };
+let lifecycle = Promise.resolve();
 
-async function startOmpProxyServer(options = {}) {
+const gateway = createOmpGateway({
+  getChannels: () => getEnabledChannels()
+});
+
+function withLifecycleLock(operation) {
+  const next = lifecycle.then(operation, operation);
+  lifecycle = next.catch(() => {});
+  return next;
+}
+
+async function startOmpProxyServerUnlocked(options = {}) {
+  if (gateway.status().listening) {
+    return {
+      success: true,
+      port: gateway.status().port,
+      sync: lastSyncResult,
+      warnings: lastSyncResult?.warnings || []
+    };
+  }
   const preserveStartTime = options.preserveStartTime || false;
   const config = loadConfig();
-  currentPort = config.ports?.ompProxy || 20092;
-  lastSyncResult = syncManagedOmpProviders();
-  running = true;
+  const wasEnabled = isManagedOmpModeEnabled();
+  const previousState = loadManagedOmpModeState?.() || {
+    activeChannelId: loadManagedOmpActiveChannelId()
+  };
+  const channels = getEnabledChannels();
+  const secret = crypto.randomBytes(32).toString('hex');
+  const desiredPort = options.port ?? config.ports?.ompProxy ?? 20092;
+  const gatewayStatus = await gateway.start({
+    host: '127.0.0.1',
+    port: desiredPort,
+    secret
+  });
+  currentPort = gatewayStatus.port;
+  try {
+    const oauthSupport = await probeOmpAuthGateways(channels);
+    const descriptor = {
+      ...gateway.descriptor(),
+      supportedOAuthChannelIds: oauthSupport.supportedOAuthChannelIds
+    };
+    lastRoutingResult = prepareManagedOmpChannels(channels, descriptor);
+    enableManagedOmpMode(options.activeChannelId, descriptor);
+    lastSyncResult = syncManagedOmpProviders(channels, {
+      gateway: descriptor,
+      activeChannelId: options.activeChannelId
+    });
+    if (oauthSupport.warnings.length > 0) {
+      lastSyncResult = {
+        ...lastSyncResult,
+        warnings: [
+          ...(lastSyncResult?.warnings || []),
+          ...oauthSupport.warnings
+        ]
+      };
+    }
+  } catch (error) {
+    if (wasEnabled) {
+      enableManagedOmpMode(previousState.activeChannelId, previousState.gateway || null);
+    } else {
+      disableManagedOmpMode();
+    }
+    await gateway.stop().catch(() => {});
+    currentPort = null;
+    throw error;
+  }
+  startOmpSessionLogObserver();
   saveProxyStartTime('omp', preserveStartTime);
   return {
     success: true,
@@ -21,12 +101,46 @@ async function startOmpProxyServer(options = {}) {
   };
 }
 
-async function stopOmpProxyServer(options = {}) {
+function startOmpProxyServer(options = {}) {
+  return withLifecycleLock(() => startOmpProxyServerUnlocked(options));
+}
+
+async function stopOmpProxyServerUnlocked(options = {}) {
   const clearStartTime = options.clearStartTime !== false;
   const stoppedPort = currentPort;
-  lastSyncResult = disableManagedOmpProviders();
-  running = false;
+  if (!gateway.status().listening && !isManagedOmpModeEnabled()) {
+    return {
+      success: true,
+      port: stoppedPort,
+      sync: lastSyncResult,
+      warnings: lastSyncResult?.warnings || []
+    };
+  }
+  const state = loadManagedOmpModeState?.() || {
+    activeChannelId: loadManagedOmpActiveChannelId()
+  };
+  const enabledChannels = getEnabledChannels();
+  const activeChannel = enabledChannels.find(channel => channel.id === state.activeChannelId)
+    || enabledChannels[0]
+    || null;
+  gateway.beginDraining();
+  stopOmpSessionLogObserver();
+  try {
+    if (activeChannel) {
+      const handoff = activateStaticOmpChannel(activeChannel.id);
+      lastSyncResult = handoff?.sync || lastSyncResult;
+    } else {
+      lastSyncResult = disableManagedOmpProviders();
+    }
+  } catch (error) {
+    startOmpSessionLogObserver();
+    gateway.cancelDraining();
+    throw error;
+  }
+  disableManagedOmpMode();
+  await gateway.stop({ forceAfterMs: options.forceAfterMs });
   currentPort = null;
+  lastRoutingResult = { routes: [], unsupportedChannels: [] };
   if (clearStartTime) {
     clearProxyStartTime('omp');
   }
@@ -38,8 +152,14 @@ async function stopOmpProxyServer(options = {}) {
   };
 }
 
+function stopOmpProxyServer(options = {}) {
+  return withLifecycleLock(() => stopOmpProxyServerUnlocked(options));
+}
+
 function getOmpProxyStatus() {
   const config = loadConfig();
+  const gatewayStatus = gateway.status();
+  const running = gatewayStatus.listening;
   const startTime = getProxyStartTime('omp', { allowRecovery: running });
   const runtime = getProxyRuntime('omp', { allowRecovery: running });
   const enabledCount = getEnabledChannels().length;
@@ -50,11 +170,23 @@ function getOmpProxyStatus() {
     defaultPort: config.ports?.ompProxy || 20092,
     startTime,
     runtime,
-    mode: 'models-yml-provider-config',
+    mode: 'http-gateway',
+    listening: gatewayStatus.listening,
+    draining: gatewayStatus.draining,
+    inflightRequests: gatewayStatus.inflightRequests,
+    routingGroups: lastRoutingResult.routes.map(route => ({
+      providerKey: route.providerKey,
+      providerApi: route.providerApi,
+      routingGroup: route.routingGroup,
+      managedProviderId: route.managedProviderId,
+      channelsCount: route.channelIds.length
+    })),
+    unsupportedChannels: lastRoutingResult.unsupportedChannels,
     enabledChannelsCount: enabledCount,
     modelsPath: lastSyncResult?.modelsPath || lastSyncResult?.path || null,
     backupPath: lastSyncResult?.backupPath || null,
     modelsValidation: validation,
+    sessionLogObserver: getOmpSessionLogObserverStatus(),
     warnings: lastSyncResult?.warnings || []
   };
 }

package/src/server/services/channel-scheduler.js

@@ -101,10 +101,35 @@ function refreshChannels(source = 'claude') {
   });
 }
 
-function getAvailableChannels(source = 'claude') {
+function matchesAllocationRequest(channel, options = {}) {
+  const candidateIds = Array.isArray(options.candidateIds)
+    ? new Set(options.candidateIds.filter(Boolean))
+    : null;
+  const excludedIds = new Set(
+    Array.isArray(options.excludeChannelIds) ? options.excludeChannelIds.filter(Boolean) : []
+  );
+  if (candidateIds && !candidateIds.has(channel.id)) return false;
+  if (excludedIds.has(channel.id)) return false;
+  if (options.routingGroup && String(channel.routingGroup || channel.id) !== String(options.routingGroup)) {
+    return false;
+  }
+  if (options.providerKey && String(channel.providerKey || channel.provider || '') !== String(options.providerKey)) {
+    return false;
+  }
+  if (
+    options.providerApi
+    && String(channel.providerApi || channel.api || channel.wireApi || 'openai-completions') !== String(options.providerApi)
+  ) {
+    return false;
+  }
+  return true;
+}
+
+function getAvailableChannels(source = 'claude', options = {}) {
   refreshChannels(source);
   const state = getState(source);
   return state.channels.filter(ch => {
+    if (!matchesAllocationRequest(ch, options)) return false;
     if (!isChannelAvailable(ch.id, source)) {
       return false;
     }
@@ -132,7 +157,7 @@ function tryAllocate(source = 'claude', options = {}) {
   const state = getState(source);
   const sessionId = options.sessionId;
   const enableSessionBinding = options.enableSessionBinding !== false; // 默认开启
-  const available = getAvailableChannels(source);
+  const available = getAvailableChannels(source, options);
   if (!available.length) {
     return null;
   }
@@ -169,6 +194,7 @@ function drainQueue(source = 'claude') {
     if (channel) {
       clearTimeout(entry.timer);
       state.queue.splice(i, 1);
+      entry.cleanup?.();
       entry.resolve(channel);
       return drainQueue(source);
     }
@@ -178,6 +204,9 @@ function drainQueue(source = 'claude') {
 function allocateChannel(options = {}) {
   const source = options.source || 'claude';
   const state = getState(source);
+  if (options.signal?.aborted) {
+    return Promise.reject(Object.assign(new Error('Channel allocation aborted'), { name: 'AbortError' }));
+  }
   const channel = tryAllocate(source, options);
   if (channel) {
     return Promise.resolve(channel);
@@ -186,16 +215,31 @@ function allocateChannel(options = {}) {
   if (!state.channels.length) {
     return Promise.reject(new Error('暂无可用渠道，请先添加并启用至少一个渠道'));
   }
+  if (!state.channels.some(ch => matchesAllocationRequest(ch, options))) {
+    return Promise.reject(new Error('没有匹配当前请求的可用渠道'));
+  }
 
   // 检查是否所有渠道都被冻结
   const allFrozen = state.channels.every(ch => !isChannelAvailable(ch.id, source));
 
   return new Promise((resolve, reject) => {
+    let entry;
+    const cleanup = () => {
+      options.signal?.removeEventListener('abort', onAbort);
+    };
+    const removeEntry = () => {
+      const index = state.queue.indexOf(entry);
+      if (index !== -1) state.queue.splice(index, 1);
+    };
+    const onAbort = () => {
+      clearTimeout(timer);
+      removeEntry();
+      cleanup();
+      reject(Object.assign(new Error('Channel allocation aborted'), { name: 'AbortError' }));
+    };
     const timer = setTimeout(() => {
-      const index = state.queue.findIndex(item => item.timer === timer);
-      if (index !== -1) {
-        state.queue.splice(index, 1);
-      }
+      removeEntry();
+      cleanup();
       // 根据实际情况返回更准确的错误信息
       if (allFrozen) {
         reject(new Error('所有渠道均已被冻结，请等待健康检查恢复或手动重置'));
@@ -204,13 +248,19 @@ function allocateChannel(options = {}) {
       }
     }, WAIT_TIMEOUT_MS);
 
-    state.queue.push({
+    entry = {
       source,
       options,
       resolve,
       reject,
-      timer
-    });
+      timer,
+      cleanup
+    };
+    state.queue.push(entry);
+    options.signal?.addEventListener('abort', onAbort, { once: true });
+    if (options.signal?.aborted) {
+      onAbort();
+    }
   });
 }
 

package/src/server/services/model-definition-schema.js

@@ -390,7 +390,8 @@ function normalizeCatalogModelList(value) {
   const warnings = [];
   for (const rawModel of Array.isArray(value) ? value : []) {
     const rawId = String(rawModel?.id || rawModel?.name || '').trim();
-    const normalized = normalizeModelSpec(rawModel, rawId);
+    const { provider: _provider, selector: _selector, ...modelFields } = isPlainObject(rawModel) ? rawModel : {};
+    const normalized = normalizeModelSpec(modelFields, rawId);
     if (!normalized.spec?.id) continue;
     warnings.push(...normalized.warnings.map(message => `${normalized.spec.id}: ${message}`));
     const key = normalized.spec.id.toLowerCase();

package/src/server/services/omp-auth-gateway-client.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const http = require('http');
+const https = require('https');
+
+function isPiNativeOAuthChannel(channel = {}) {
+  const transport = String(channel.transport || channel.providerConfig?.transport || '').trim();
+  return channel.authMode === 'oauth'
+    && transport === 'pi-native'
+    && Boolean(String(channel.apiKey || '').trim())
+    && Boolean(String(channel.baseUrl || '').trim());
+}
+
+function probeHealth(channel, timeoutMs) {
+  return new Promise((resolve) => {
+    let target;
+    try {
+      target = new URL('/healthz', channel.baseUrl);
+    } catch {
+      resolve(false);
+      return;
+    }
+    const transport = target.protocol === 'https:' ? https : http;
+    const request = transport.request(target, {
+      method: 'GET',
+      headers: {
+        accept: 'application/json'
+      }
+    }, (response) => {
+      response.resume();
+      response.once('end', () => {
+        resolve((response.statusCode || 0) >= 200 && (response.statusCode || 0) < 300);
+      });
+    });
+    request.setTimeout(timeoutMs, () => {
+      request.destroy(new Error('OMP auth gateway health probe timed out'));
+    });
+    request.once('error', () => resolve(false));
+    request.end();
+  });
+}
+
+async function probeOmpAuthGateways(channels = [], options = {}) {
+  const candidates = channels.filter(isPiNativeOAuthChannel);
+  const timeoutMs = Math.max(100, Number(options.timeoutMs) || 1000);
+  const results = await Promise.all(candidates.map(async (channel) => ({
+    channel,
+    healthy: await probeHealth(channel, timeoutMs)
+  })));
+  return {
+    supportedOAuthChannelIds: results
+      .filter(result => result.healthy)
+      .map(result => result.channel.id),
+    warnings: results
+      .filter(result => !result.healthy)
+      .map(result => `OMP OAuth auth gateway for channel "${result.channel.name || result.channel.id}" is unavailable; the native OMP provider remains active.`)
+  };
+}
+
+module.exports = {
+  probeOmpAuthGateways
+};

package/src/server/services/omp-channels.js

@@ -1,13 +1,12 @@
 const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
-const { PATHS } = require('../../config/paths');
+const { PATHS, ensureStorageDirMigrated } = require('../../config/paths');
 const BaseChannelService = require('./base/base-channel-service');
 const ompConfig = require('./omp-config');
 const {
   writeManagedOmpProviders,
   removeManagedOmpProviders,
-  isManagedOmpProvidersActive,
   getLastManagedOmpSyncResult,
   readModelsConfig,
   readOmpSettingsConfig,
@@ -23,13 +22,100 @@ const {
 
 const OMP_THINKING_SUFFIX_RE = /:(minimal|low|medium|high|xhigh|off)$/;
 
+function clearOmpChannelBalanceCache(channel) {
+  try {
+    require('./channel-balance').clearChannelBalanceCache('omp', channel);
+  } catch (_) {
+    // Balance cache invalidation is an optimization; channel activation must still succeed.
+  }
+}
+
+function selectLatestEnabledChannel(channels = []) {
+  const enabledChannels = (channels || []).filter(channel => channel?.enabled !== false);
+  if (enabledChannels.length === 0) return null;
+  return enabledChannels.reduce((latest, current) => {
+    const latestTs = Number(latest?.updatedAt || latest?.createdAt || 0);
+    const currentTs = Number(current?.updatedAt || current?.createdAt || 0);
+    return currentTs > latestTs ? current : latest;
+  }, enabledChannels[0]);
+}
+
+function loadManagedOmpModeState() {
+  ensureStorageDirMigrated();
+  try {
+    if (!fs.existsSync(PATHS.activeChannel.omp)) return null;
+    const data = JSON.parse(fs.readFileSync(PATHS.activeChannel.omp, 'utf8'));
+    return data && typeof data === 'object' && !Array.isArray(data) ? data : null;
+  } catch {
+    return null;
+  }
+}
+
+function loadManagedOmpActiveChannelId() {
+  return loadManagedOmpModeState()?.activeChannelId || null;
+}
+
+function isManagedOmpModeEnabled() {
+  ensureStorageDirMigrated();
+  return fs.existsSync(PATHS.activeChannel.omp);
+}
+
+function writeManagedOmpModeState(filePath, state) {
+  const temporaryPath = `${filePath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    fs.writeFileSync(temporaryPath, JSON.stringify(state, null, 2), {
+      encoding: 'utf8',
+      mode: 0o600
+    });
+    fs.renameSync(temporaryPath, filePath);
+  } catch (error) {
+    if (fs.existsSync(temporaryPath)) fs.unlinkSync(temporaryPath);
+    throw error;
+  }
+}
+
+function enableManagedOmpMode(activeChannelId = null, gateway = null) {
+  ensureStorageDirMigrated();
+  const filePath = PATHS.activeChannel.omp;
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const nextActiveChannelId = activeChannelId || loadManagedOmpActiveChannelId();
+  const previousState = loadManagedOmpModeState();
+  const nextGateway = gateway || previousState?.gateway || null;
+  const state = {
+    version: 2,
+    activeChannelId: nextActiveChannelId || null
+  };
+  if (nextGateway) {
+    state.gateway = {
+      host: String(nextGateway.host || '127.0.0.1'),
+      port: Number(nextGateway.port),
+      secret: String(nextGateway.secret || ''),
+      supportedOAuthChannelIds: Array.isArray(nextGateway.supportedOAuthChannelIds)
+        ? [...nextGateway.supportedOAuthChannelIds]
+        : []
+    };
+  }
+  writeManagedOmpModeState(filePath, state);
+  return nextActiveChannelId || null;
+}
+
+function disableManagedOmpMode() {
+  ensureStorageDirMigrated();
+  if (fs.existsSync(PATHS.activeChannel.omp)) {
+    fs.unlinkSync(PATHS.activeChannel.omp);
+  }
+}
+
 class OmpChannelService extends BaseChannelService {
   constructor() {
     super({
       platform: 'omp',
       channelsFilePath: PATHS.channels.omp,
       defaultGatewaySource: 'openai_compatible',
-      isProxyRunning: () => isManagedOmpProvidersActive()
+      isProxyRunning: () => isManagedOmpModeEnabled()
     });
   }
 
@@ -37,10 +123,16 @@ class OmpChannelService extends BaseChannelService {
     const normalized = super._applyDefaults(channel);
     normalized.providerKey = normalized.providerKey || normalized.provider || normalized.name || normalized.id;
     normalized.providerApi = normalized.providerApi || normalized.api || normalized.wireApi || 'openai-completions';
-    normalized.authMode = normalized.authMode === 'oauth' ? 'oauth' : 'api_key';
+    normalized.authMode = ['api_key', 'oauth', 'none'].includes(normalized.authMode)
+      ? normalized.authMode
+      : 'api_key';
+    normalized.routingGroup = String(normalized.routingGroup || '').trim();
     normalized.oauthProviderId = normalized.oauthProviderId || (normalized.authMode === 'oauth' ? normalized.providerKey : '');
     if (normalized.authMode === 'oauth') {
       normalized.apiKey = normalized.apiKey || '';
+    } else if (normalized.authMode === 'none') {
+      normalized.apiKey = '';
+      normalized.oauthProviderId = '';
     }
     normalized.model = normalized.model || null;
     normalized.models = Array.isArray(normalized.models) ? normalized.models : [];
@@ -59,28 +151,49 @@ class OmpChannelService extends BaseChannelService {
   }
 
   _applyToNativeSettings(channel) {
-    writeManagedOmpProviders([channel]);
+    if (isManagedOmpModeEnabled()) {
+      const state = loadManagedOmpModeState();
+      enableManagedOmpMode(channel.id, state?.gateway || null);
+      writeManagedOmpProviders([channel], state?.gateway ? {
+        gateway: state.gateway,
+        activeChannelId: channel.id
+      } : {});
+      return;
+    }
+    writeManagedOmpProviders([channel], {});
   }
 
   _onAfterCreate(_channel, allChannels) {
-    this.syncManagedOmpProviders(allChannels);
+    this.syncOmpProvidersForCurrentMode(allChannels);
   }
 
   _onAfterUpdate(_oldChannel, _newChannel, allChannels) {
-    this.syncManagedOmpProviders(allChannels);
+    this.syncOmpProvidersForCurrentMode(allChannels);
   }
 
   _onAfterDelete(_channel, allChannels) {
-    this.syncManagedOmpProviders(allChannels);
+    this.syncOmpProvidersForCurrentMode(allChannels);
+  }
+
+  syncOmpProvidersForCurrentMode(channels = this.getChannels().channels) {
+    if (isManagedOmpModeEnabled()) {
+      const state = loadManagedOmpModeState();
+      return this.syncManagedOmpProviders(channels, state?.gateway ? {
+        gateway: state.gateway,
+        activeChannelId: state.activeChannelId
+      } : {});
+    }
+    const activeChannel = selectLatestEnabledChannel(channels);
+    return this.syncManagedOmpProviders(activeChannel ? [activeChannel] : [], {});
   }
 
-  syncManagedOmpProviders(channels = this.getChannels().channels) {
+  syncManagedOmpProviders(channels = this.getChannels().channels, options = {}) {
     const enabledChannels = (channels || []).filter(channel => channel.enabled !== false);
     if (enabledChannels.length === 0) {
       removeManagedOmpProviders();
       return getLastManagedOmpSyncResult();
     }
-    writeManagedOmpProviders(enabledChannels);
+    writeManagedOmpProviders(enabledChannels, options);
     return getLastManagedOmpSyncResult();
   }
 
@@ -89,8 +202,45 @@ class OmpChannelService extends BaseChannelService {
     return getLastManagedOmpSyncResult();
   }
 
+  activateStaticOmpChannel(channelId) {
+    const data = this.loadChannels();
+    const channel = data.channels.find(item => item.id === channelId);
+    if (!channel) {
+      throw new Error('Channel not found');
+    }
+
+    const previousData = JSON.parse(JSON.stringify(data));
+    const wasEnabled = channel.enabled !== false;
+    data.channels.forEach(item => {
+      item.enabled = item.id === channelId;
+    });
+
+    try {
+      this.saveChannels(data);
+      const sync = this.syncManagedOmpProviders([channel], {});
+      if (!wasEnabled) {
+        clearOmpChannelBalanceCache(channel);
+      }
+      return { channel, sync };
+    } catch (error) {
+      try {
+        this.saveChannels(previousData);
+      } catch (rollbackError) {
+        error.rollbackError = rollbackError;
+      }
+      throw error;
+    }
+  }
+
+  applyChannelToSettings(channelId) {
+    if (isManagedOmpModeEnabled()) {
+      return super.applyChannelToSettings(channelId);
+    }
+    return this.activateStaticOmpChannel(channelId).channel;
+  }
+
   syncManagedProviderExtension(channels = this.getChannels().channels) {
-    return this.syncManagedOmpProviders(channels);
+    return this.syncOmpProvidersForCurrentMode(channels);
   }
 
   disableManagedProviderExtension() {
@@ -394,11 +544,17 @@ module.exports = {
   getEnabledChannels: () => service.getEnabledChannels(),
   saveChannelOrder: (order) => service.saveChannelOrder(order),
   applyChannelToSettings: (id) => service.applyChannelToSettings(id),
+  activateStaticOmpChannel: (id) => service.activateStaticOmpChannel(id),
   disableAllChannels: () => service.disableAllChannels(),
   getEffectiveApiKey: (channel) => channel?.apiKey || null,
-  syncManagedOmpProviders: (channels) => service.syncManagedOmpProviders(channels),
+  syncManagedOmpProviders: (channels, options) => service.syncManagedOmpProviders(channels, options),
   disableManagedOmpProviders: () => service.disableManagedOmpProviders(),
   syncManagedProviderExtension: (channels) => service.syncManagedProviderExtension(channels),
   disableManagedProviderExtension: () => service.disableManagedProviderExtension(),
+  isManagedOmpModeEnabled,
+  enableManagedOmpMode,
+  disableManagedOmpMode,
+  loadManagedOmpModeState,
+  loadManagedOmpActiveChannelId,
   syncCurrentOmpChannel
 };