coding-tool-x 3.7.1 → 3.7.3

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

@@ -5,7 +5,8 @@ const {
   createChannel,
   updateChannel,
   deleteChannel,
-  saveChannelOrder
+  saveChannelOrder,
+  syncCurrentOmpChannel
 } = require('../services/omp-channels');
 const { isOmpInstalled } = require('../services/omp-sessions');
 const { getSchedulerState } = require('../services/channel-scheduler');
@@ -61,6 +62,63 @@ function collectPreferredModels(channel = {}) {
   ]);
 }
 
+function resolveModelDiscoverySourceType(gatewaySourceType) {
+  return gatewaySourceType === 'opencode' ? 'openai_compatible' : gatewaySourceType;
+}
+
+async function discoverOmpModels(channel, gatewaySourceType, { forceRefresh = false } = {}) {
+  if (channel?.authMode === 'oauth' && !String(channel.apiKey || '').trim()) {
+    const preferredModels = collectPreferredModels(channel);
+    return {
+      models: preferredModels,
+      supported: preferredModels.length > 0,
+      cached: false,
+      fallbackUsed: true,
+      fetchedAt: new Date().toISOString(),
+      error: preferredModels.length > 0 ? null : 'OAuth 渠道未配置 API Key，无法直接调用远端模型列表接口',
+      errorHint: '请手动填写默认模型、测速模型或可用模型；运行时由 OMP 的登录凭证提供访问权限'
+    };
+  }
+
+  const discoverySourceType = resolveModelDiscoverySourceType(gatewaySourceType);
+  const listResult = await fetchModelsFromProvider(channel, discoverySourceType, {
+    useV1ModelsEndpoint: true,
+    forceRefresh
+  });
+  const listedModels = Array.isArray(listResult.models) ? uniqueModels(listResult.models) : [];
+
+  if (listedModels.length > 0) {
+    return {
+      models: listedModels,
+      supported: true,
+      cached: !!listResult.cached,
+      fallbackUsed: false,
+      fetchedAt: listResult.lastChecked || new Date().toISOString(),
+      error: null,
+      errorHint: null
+    };
+  }
+
+  const probe = await probeModelAvailability(channel, discoverySourceType, {
+    stopOnFirstAvailable: false,
+    preferredModels: collectPreferredModels(channel),
+    forceRefresh
+  });
+  const probedModels = Array.isArray(probe.availableModels) ? uniqueModels(probe.availableModels) : [];
+
+  return {
+    models: probedModels,
+    supported: probedModels.length > 0,
+    cached: !!probe.cached || !!listResult.cached,
+    fallbackUsed: probedModels.length > 0,
+    fetchedAt: probe.lastChecked || listResult.lastChecked || new Date().toISOString(),
+    error: probedModels.length > 0 ? null : (listResult.error || '无法获取可用模型'),
+    errorHint: probedModels.length > 0
+      ? '模型列表接口不可用，已自动切换为模型探测结果'
+      : (listResult.errorHint || '请手动填写模型名称')
+  };
+}
+
 function attachAuthProvider(channel, snapshot) {
   const authProvider = findAuthProviderForKey(channel.providerKey || channel.provider || channel.name, snapshot);
   if (!authProvider) return channel;
@@ -114,25 +172,57 @@ module.exports = () => {
     }
   });
 
+  router.post('/sync-current', (req, res) => {
+    try {
+      if (!isOmpInstalled()) {
+        return res.status(404).json({ error: 'OMP CLI not installed' });
+      }
+
+      const result = syncCurrentOmpChannel();
+      res.json(result);
+      broadcastSchedulerState('omp', getSchedulerState('omp'));
+    } catch (err) {
+      console.error('[OMP Channels API] Failed to sync current channel:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
   router.post('/probe-models', async (req, res) => {
     try {
-      const { baseUrl, apiKey, gatewaySourceType } = req.body || {};
+      const {
+        baseUrl,
+        apiKey,
+        gatewaySourceType,
+        authMode,
+        oauthProviderId,
+        model,
+        speedTestModel,
+        allowedModels,
+        modelRedirects
+      } = req.body || {};
       if (!baseUrl) {
         return res.status(400).json({ error: 'baseUrl is required' });
       }
-      const tempChannel = { baseUrl, apiKey: apiKey || '', gatewaySourceType: gatewaySourceType || 'openai_compatible' };
+      const tempChannel = {
+        name: 'Temporary OMP Channel',
+        baseUrl,
+        apiKey: apiKey || '',
+        gatewaySourceType: gatewaySourceType || 'openai_compatible',
+        authMode: authMode === 'oauth' ? 'oauth' : 'api_key',
+        oauthProviderId: oauthProviderId || '',
+        model: model || null,
+        speedTestModel: speedTestModel || null,
+        allowedModels: Array.isArray(allowedModels) ? allowedModels : [],
+        modelRedirects: Array.isArray(modelRedirects) ? modelRedirects : []
+      };
       const resolvedGatewaySourceType = resolveGatewaySourceType(tempChannel);
-      const modelListSourceType = resolvedGatewaySourceType === 'opencode' ? 'openai_compatible' : resolvedGatewaySourceType;
-      const listResult = await fetchModelsFromProvider(tempChannel, modelListSourceType, {
-        useV1ModelsEndpoint: true,
-        forceRefresh: true
-      });
-      const models = Array.isArray(listResult.models) ? uniqueModels(listResult.models) : [];
+      const result = await discoverOmpModels(tempChannel, resolvedGatewaySourceType, { forceRefresh: true });
       res.json({
-        models,
-        supported: models.length > 0,
-        error: models.length > 0 ? null : (listResult.error || '未返回可用模型列表'),
-        errorHint: models.length > 0 ? null : (listResult.errorHint || '请手动填写模型名称')
+        models: result.models,
+        supported: result.supported,
+        fallbackUsed: result.fallbackUsed,
+        error: result.error,
+        errorHint: result.errorHint
       });
     } catch (error) {
       console.error('[OMP Channels API] Error probing models:', error);
@@ -150,35 +240,18 @@ module.exports = () => {
       }
       const forceRefresh = req.query.forceRefresh === 'true';
       const gatewaySourceType = resolveGatewaySourceType(channel);
-      const modelListSourceType = gatewaySourceType === 'opencode' ? 'openai_compatible' : gatewaySourceType;
-      const listResult = await fetchModelsFromProvider(channel, modelListSourceType, {
-        useV1ModelsEndpoint: true,
-        forceRefresh
-      });
-      let models = Array.isArray(listResult.models) ? uniqueModels(listResult.models) : [];
-      let error = models.length > 0 ? null : listResult.error;
-      let errorHint = models.length > 0 ? null : listResult.errorHint;
-
-      if (models.length === 0) {
-        const probe = await probeModelAvailability(channel, gatewaySourceType, {
-          stopOnFirstAvailable: false,
-          preferredModels: collectPreferredModels(channel)
-        });
-        models = Array.isArray(probe.availableModels) ? uniqueModels(probe.availableModels) : [];
-        error = models.length > 0 ? null : (error || '无法获取可用模型');
-        errorHint = models.length > 0 ? '模型列表接口不可用，已自动切换为模型探测结果' : (errorHint || '请手动填写模型名称');
-      }
+      const result = await discoverOmpModels(channel, gatewaySourceType, { forceRefresh });
 
       res.json({
         channelId,
         gatewaySourceType,
-        models,
-        supported: models.length > 0,
-        cached: !!listResult.cached,
-        fallbackUsed: false,
-        fetchedAt: listResult.lastChecked || new Date().toISOString(),
-        error,
-        errorHint
+        models: result.models,
+        supported: result.supported,
+        cached: result.cached,
+        fallbackUsed: result.fallbackUsed,
+        fetchedAt: result.fetchedAt,
+        error: result.error,
+        errorHint: result.errorHint
       });
     } catch (error) {
       console.error('[OMP Channels API] Error fetching models:', error);
@@ -203,6 +276,8 @@ module.exports = () => {
         speedTestModel,
         providerKey,
         providerApi,
+        authMode,
+        oauthProviderId,
         presetId,
         websiteUrl,
         balanceToken,
@@ -212,7 +287,8 @@ module.exports = () => {
       if (!name || !baseUrl) {
         return res.status(400).json({ error: 'Missing required fields: name and baseUrl' });
       }
-      if (!apiKey) {
+      const normalizedAuthMode = authMode === 'oauth' ? 'oauth' : 'api_key';
+      if (!apiKey && normalizedAuthMode !== 'oauth') {
         return res.status(400).json({ error: 'API Key is required' });
       }
 
@@ -220,6 +296,8 @@ module.exports = () => {
         wireApi: wireApi || 'openai',
         providerApi: providerApi || wireApi || 'openai-completions',
         providerKey,
+        authMode: normalizedAuthMode,
+        oauthProviderId: oauthProviderId || providerKey || '',
         enabled,
         weight,
         maxConcurrency,

package/src/server/api/opencode-channels.js

@@ -5,7 +5,8 @@ const {
   createChannel,
   updateChannel,
   deleteChannel,
-  saveChannelOrder
+  saveChannelOrder,
+  syncCurrentOpenCodeChannel
 } = require('../services/opencode-channels');
 const { isOpenCodeInstalled } = require('../services/opencode-sessions');
 const { getSchedulerState } = require('../services/channel-scheduler');
@@ -131,6 +132,25 @@ module.exports = (config) => {
     }
   });
 
+  /**
+   * POST /api/opencode/channels/sync-current
+   * 将当前 OpenCode 原生/ctx 配置同步到渠道列表
+   */
+  router.post('/sync-current', (req, res) => {
+    try {
+      if (!isOpenCodeInstalled()) {
+        return res.status(404).json({ error: 'OpenCode CLI not installed' });
+      }
+
+      const result = syncCurrentOpenCodeChannel();
+      res.json(result);
+      broadcastSchedulerState('opencode', getSchedulerState('opencode'));
+    } catch (err) {
+      console.error('[OpenCode Channels API] Failed to sync current channel:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
   /**
    * POST /api/opencode/channels/probe-models
    * 用临时配置（新建渠道时）获取模型列表，无需 channelId

package/src/server/index.js

@@ -24,7 +24,10 @@ const { startCodexProxyServer } = require('./codex-proxy-server');
 const { startGeminiProxyServer } = require('./gemini-proxy-server');
 const { startOpenCodeProxyServer, collectProxyModelList } = require('./opencode-proxy-server');
 const { startOmpProxyServer } = require('./omp-proxy-server');
-const { createRemoteMutationGuard } = require('./services/network-access');
+const {
+  createRemoteMutationGuard,
+  isRemoteMutationAllowedByEnv
+} = require('./services/network-access');
 const { createApiRequestLogger } = require('./services/request-logger');
 const { inspectWebBuildState, ensureWebDistReady } = require('./services/web-build');
 const { ensureHttpsCredentials } = require('./services/https-cert');
@@ -151,7 +154,7 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
   const app = express();
   const useHttps = options.useHttps === true || process.argv.includes('--https');
   const lanMode = host === '0.0.0.0';
-  const allowRemoteMutation = process.env.CC_TOOL_ALLOW_REMOTE_WRITE === 'true';
+  const allowRemoteMutation = isRemoteMutationAllowedByEnv(process.env);
 
   // Middleware
   app.use(express.json({ limit: '100mb' }));
@@ -175,7 +178,7 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
     app.use('/api', createRemoteMutationGuard({
       enabled: true,
       allowRemoteMutation,
-      message: '出于安全考虑，LAN 模式默认仅允许本机执行写操作。可设置 CC_TOOL_ALLOW_REMOTE_WRITE=true 覆盖。'
+      message: 'LAN 模式下远程写操作已被 CC_TOOL_ALLOW_REMOTE_WRITE=false 禁止。'
     }));
 
   }
@@ -325,8 +328,13 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
     console.log(chalk.gray('   [TIP] 首次访问自签名证书时，浏览器可能会提示手动信任本地证书'));
   }
 
-  if (host === '0.0.0.0' && !allowRemoteMutation) {
-    console.log(chalk.yellow('   [LOCK] 已启用 LAN 安全保护：远程写操作默认禁用'));
+  if (host === '0.0.0.0') {
+    if (allowRemoteMutation) {
+      console.log(chalk.yellow('   [WARN]  LAN 远程写操作已启用（默认行为）'));
+      console.log(chalk.gray('   如需禁止，请设置 CC_TOOL_ALLOW_REMOTE_WRITE=false'));
+    } else {
+      console.log(chalk.yellow('   [LOCK] 已启用 LAN 安全保护：远程写操作被 CC_TOOL_ALLOW_REMOTE_WRITE=false 禁止'));
+    }
   }
   // 自动恢复代理状态
   autoRestoreProxies();

package/src/server/services/channel-sync-utils.js

@@ -0,0 +1,368 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { PATHS, ensureStorageDirMigrated } = require('../../config/paths');
+
+function normalizeString(value) {
+  return String(value || '').trim();
+}
+
+function normalizeLower(value) {
+  return normalizeString(value).toLowerCase();
+}
+
+function normalizeUrl(value) {
+  const raw = normalizeString(value);
+  if (!raw) return '';
+  return raw.replace(/\/+$/, '').toLowerCase();
+}
+
+function isLocalProxyBaseUrl(value) {
+  const raw = normalizeString(value);
+  if (!raw) return false;
+  try {
+    const parsed = new URL(raw);
+    const host = normalizeLower(parsed.hostname).replace(/^\[|\]$/g, '');
+    return host === 'localhost' || host === '127.0.0.1' || host === '::1';
+  } catch {
+    return raw.includes('127.0.0.1') || raw.includes('localhost');
+  }
+}
+
+function isProxyCredential(value) {
+  const raw = normalizeString(value);
+  return raw === 'PROXY_KEY' || raw === 'CC_PROXY_KEY';
+}
+
+function parseEnvReference(value) {
+  const raw = normalizeString(value);
+  if (!raw) return '';
+  let match = raw.match(/^\$\{?([A-Z_][A-Z0-9_]*)\}?$/);
+  if (match) return match[1];
+  match = raw.match(/^env:([A-Z_][A-Z0-9_]*)$/i);
+  if (match) return match[1].toUpperCase();
+  match = raw.match(/^process\.env\.([A-Z_][A-Z0-9_]*)$/);
+  if (match) return match[1];
+  if (/^[A-Z_][A-Z0-9_]*$/.test(raw) && /(?:API|KEY|TOKEN|SECRET|AUTH)/.test(raw)) {
+    return raw;
+  }
+  return '';
+}
+
+function resolveApiKeyValue(value, env = process.env) {
+  const raw = normalizeString(value);
+  if (!raw || isProxyCredential(raw)) {
+    return { value: '', source: '', envName: '' };
+  }
+
+  const envName = parseEnvReference(raw);
+  if (envName) {
+    const envValue = normalizeString(env?.[envName]);
+    if (isProxyCredential(envValue)) {
+      return { value: '', source: 'proxy-env', envName };
+    }
+    return {
+      value: envValue,
+      source: envValue ? 'env' : 'env-missing',
+      envName
+    };
+  }
+
+  return { value: raw, source: 'config', envName: '' };
+}
+
+function readActiveChannelId(platform) {
+  try {
+    ensureStorageDirMigrated?.();
+    const filePath = PATHS.activeChannel?.[platform];
+    if (!filePath || !fs.existsSync(filePath)) return null;
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return data?.activeChannelId || null;
+  } catch {
+    return null;
+  }
+}
+
+function selectLatestEnabledChannel(channels = []) {
+  const enabledChannels = (Array.isArray(channels) ? channels : [])
+    .filter(channel => 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 resolveExistingActiveChannel(platform, channels = []) {
+  const allChannels = Array.isArray(channels) ? channels : [];
+  const activeChannelId = readActiveChannelId(platform);
+  if (activeChannelId) {
+    const matched = allChannels.find(channel => channel.id === activeChannelId);
+    if (matched) return matched;
+  }
+  return selectLatestEnabledChannel(allChannels)
+    || allChannels.find(channel => channel.enabled !== false)
+    || allChannels[0]
+    || null;
+}
+
+function secretHash(value) {
+  const raw = normalizeString(value);
+  if (!raw) return '';
+  return crypto.createHash('sha256').update(raw).digest('hex');
+}
+
+function channelIdentity(channel = {}) {
+  return {
+    id: normalizeString(channel.id),
+    providerKey: normalizeLower(channel.providerKey || channel.provider),
+    baseUrl: normalizeUrl(channel.baseUrl),
+    apiKeyHash: secretHash(channel.apiKey || channel.key),
+    model: normalizeLower(channel.model),
+    name: normalizeLower(channel.name)
+  };
+}
+
+function defaultFindExistingChannel(channels = [], candidate = {}, options = {}) {
+  const target = channelIdentity(candidate);
+  const candidateId = normalizeString(candidate.id);
+  if (candidateId) {
+    const byId = channels.find(channel => channel.id === candidateId);
+    if (byId) return byId;
+  }
+
+  const matchers = Array.isArray(options.matchers) ? options.matchers : [];
+  for (const matcher of matchers) {
+    const matched = channels.find(channel => matcher(channel, candidate));
+    if (matched) return matched;
+  }
+
+  if (target.providerKey) {
+    const byProvider = channels.find(channel => channelIdentity(channel).providerKey === target.providerKey);
+    if (byProvider) return byProvider;
+  }
+
+  if (target.baseUrl && target.apiKeyHash) {
+    const byUrlAndKey = channels.find((channel) => {
+      const identity = channelIdentity(channel);
+      return identity.baseUrl === target.baseUrl && identity.apiKeyHash === target.apiKeyHash;
+    });
+    if (byUrlAndKey) return byUrlAndKey;
+  }
+
+  if (target.baseUrl && target.model) {
+    const byUrlAndModel = channels.find((channel) => {
+      const identity = channelIdentity(channel);
+      return identity.baseUrl === target.baseUrl && identity.model === target.model;
+    });
+    if (byUrlAndModel) return byUrlAndModel;
+  }
+
+  if (target.baseUrl) {
+    return channels.find(channel => channelIdentity(channel).baseUrl === target.baseUrl) || null;
+  }
+
+  return null;
+}
+
+function shouldPreserveField(field, existing, candidate) {
+  if (field === 'name') {
+    return normalizeString(existing?.name) && normalizeLower(existing.name) !== 'default';
+  }
+  return Object.prototype.hasOwnProperty.call(existing || {}, field)
+    && !Object.prototype.hasOwnProperty.call(candidate || {}, field);
+}
+
+function mergeSyncedChannel(existing, candidate, options = {}) {
+  const preserveFields = options.preserveFields || [
+    'id',
+    'createdAt',
+    'name',
+    'enabled',
+    'weight',
+    'maxConcurrency',
+    'balanceToken',
+    'balanceUserId'
+  ];
+
+  const merged = {
+    ...existing,
+    ...candidate,
+    id: existing.id,
+    createdAt: existing.createdAt || candidate.createdAt || Date.now(),
+    updatedAt: Date.now()
+  };
+
+  for (const field of preserveFields) {
+    if (shouldPreserveField(field, existing, candidate)) {
+      merged[field] = existing[field];
+    }
+  }
+
+  return merged;
+}
+
+function stableComparableValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(stableComparableValue);
+  }
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+  return Object.keys(value)
+    .sort()
+    .reduce((acc, key) => {
+      acc[key] = stableComparableValue(value[key]);
+      return acc;
+    }, {});
+}
+
+function comparableChannel(channel = {}) {
+  const copy = { ...channel };
+  delete copy.updatedAt;
+  delete copy.health;
+  delete copy.websiteUrl;
+  return JSON.stringify(stableComparableValue(copy));
+}
+
+function sanitizeChannel(channel) {
+  if (!channel) return null;
+  const sanitized = {
+    id: channel.id,
+    name: channel.name,
+    baseUrl: channel.baseUrl,
+    enabled: channel.enabled !== false
+  };
+  if (channel.providerKey) sanitized.providerKey = channel.providerKey;
+  if (channel.model) sanitized.model = channel.model;
+  if (channel.credentialSource) sanitized.credentialSource = channel.credentialSource;
+  return sanitized;
+}
+
+function createSkippedResult(toolType, warning, channel = null) {
+  return {
+    success: true,
+    toolType,
+    added: 0,
+    updated: 0,
+    skipped: 1,
+    channels: channel ? [sanitizeChannel(channel)] : [],
+    warnings: warning ? [warning] : []
+  };
+}
+
+function upsertSyncedChannels({
+  toolType,
+  loadChannels,
+  saveChannels,
+  applyDefaults,
+  candidates,
+  matchers,
+  preserveFields
+}) {
+  const data = loadChannels();
+  const channels = Array.isArray(data?.channels) ? [...data.channels] : [];
+  const result = {
+    success: true,
+    toolType,
+    added: 0,
+    updated: 0,
+    skipped: 0,
+    channels: [],
+    warnings: []
+  };
+
+  let changed = false;
+  for (const rawCandidate of candidates || []) {
+    const candidate = rawCandidate || {};
+    if (candidate.warning) {
+      result.warnings.push(candidate.warning);
+    }
+    if (candidate.skip) {
+      result.skipped += 1;
+      if (candidate.channel) result.channels.push(sanitizeChannel(candidate.channel));
+      continue;
+    }
+    if (!normalizeString(candidate.baseUrl)) {
+      result.skipped += 1;
+      result.warnings.push(`${toolType}: missing baseUrl, skipped current channel sync`);
+      continue;
+    }
+    if (!normalizeString(candidate.apiKey)) {
+      result.skipped += 1;
+      result.warnings.push(`${toolType}: missing API key or OAuth-only config, skipped current channel sync`);
+      continue;
+    }
+
+    const normalizedCandidate = applyDefaults ? applyDefaults(candidate) : candidate;
+    const existing = defaultFindExistingChannel(channels, normalizedCandidate, { matchers });
+    if (existing) {
+      const merged = applyDefaults
+        ? applyDefaults(mergeSyncedChannel(existing, normalizedCandidate, { preserveFields }))
+        : mergeSyncedChannel(existing, normalizedCandidate, { preserveFields });
+      if (comparableChannel(existing) === comparableChannel(merged)) {
+        result.skipped += 1;
+        result.channels.push(sanitizeChannel(existing));
+        continue;
+      }
+      const index = channels.findIndex(channel => channel.id === existing.id);
+      channels[index] = merged;
+      changed = true;
+      result.updated += 1;
+      result.channels.push(sanitizeChannel(merged));
+      continue;
+    }
+
+    const now = Date.now();
+    const created = applyDefaults ? applyDefaults({
+      id: candidate.id || crypto.randomUUID(),
+      enabled: candidate.enabled !== false,
+      weight: candidate.weight || 1,
+      maxConcurrency: candidate.maxConcurrency || null,
+      ...normalizedCandidate,
+      createdAt: now,
+      updatedAt: now
+    }) : {
+      id: candidate.id || crypto.randomUUID(),
+      enabled: candidate.enabled !== false,
+      weight: candidate.weight || 1,
+      maxConcurrency: candidate.maxConcurrency || null,
+      ...normalizedCandidate,
+      createdAt: now,
+      updatedAt: now
+    };
+    channels.push(created);
+    changed = true;
+    result.added += 1;
+    result.channels.push(sanitizeChannel(created));
+  }
+
+  if (changed) {
+    const dir = path.dirname(loadChannels.filePath || '');
+    if (dir && dir !== '.' && !fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    saveChannels({ ...data, channels });
+  }
+
+  result.warnings = [...new Set(result.warnings.filter(Boolean))];
+  return result;
+}
+
+module.exports = {
+  createSkippedResult,
+  defaultFindExistingChannel,
+  isLocalProxyBaseUrl,
+  isProxyCredential,
+  normalizeLower,
+  normalizeString,
+  normalizeUrl,
+  readActiveChannelId,
+  resolveApiKeyValue,
+  resolveExistingActiveChannel,
+  sanitizeChannel,
+  secretHash,
+  selectLatestEnabledChannel,
+  upsertSyncedChannels
+};