coding-tool-x 3.7.11 → 3.7.13

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

@@ -1,3 +1,4 @@
+const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
@@ -15,6 +16,7 @@ const {
 } = require('./omp-settings-manager');
 const {
   createSkippedResult,
+  isLocalProxyBaseUrl,
   resolveApiKeyValue,
   resolveExistingActiveChannel,
   upsertSyncedChannels
@@ -22,6 +24,24 @@ 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 {
@@ -56,6 +76,54 @@ function writeManagedOmpModeState(filePath, state) {
   }
 }
 
+function getOmpGatewaySecretPath() {
+  return PATHS.ompGatewaySecret
+    || path.join(path.dirname(PATHS.activeChannel.omp), 'omp-gateway-secret');
+}
+
+function writeOmpGatewaySecret(filePath, secret) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  const temporaryPath = `${filePath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    fs.writeFileSync(temporaryPath, `${secret}\n`, { encoding: 'utf8', mode: 0o600 });
+    fs.chmodSync(temporaryPath, 0o600);
+    fs.renameSync(temporaryPath, filePath);
+  } catch (error) {
+    if (fs.existsSync(temporaryPath)) fs.unlinkSync(temporaryPath);
+    throw error;
+  }
+}
+
+function getOrCreateOmpGatewaySecret() {
+  ensureStorageDirMigrated();
+  const filePath = getOmpGatewaySecretPath();
+  const previousStateSecret = loadManagedOmpModeState()?.gateway?.secret;
+  const fileExists = fs.existsSync(filePath);
+
+  if (fileExists) {
+    try {
+      const stored = fs.readFileSync(filePath, 'utf8').trim();
+      if (stored) return stored;
+    } catch (error) {
+      if (previousStateSecret) {
+        writeOmpGatewaySecret(filePath, previousStateSecret);
+        return previousStateSecret;
+      }
+      throw new Error(`Failed to read persisted OMP gateway secret: ${error.message}`);
+    }
+    if (!previousStateSecret) {
+      throw new Error('Persisted OMP gateway secret is empty');
+    }
+    writeOmpGatewaySecret(filePath, previousStateSecret);
+    return previousStateSecret;
+  }
+
+  const secret = String(previousStateSecret || crypto.randomBytes(32).toString('hex'));
+  writeOmpGatewaySecret(filePath, secret);
+  return secret;
+}
+
 function enableManagedOmpMode(activeChannelId = null, gateway = null) {
   ensureStorageDirMigrated();
   const filePath = PATHS.activeChannel.omp;
@@ -140,30 +208,33 @@ class OmpChannelService extends BaseChannelService {
         gateway: state.gateway,
         activeChannelId: channel.id
       } : {});
+      return;
     }
+    writeManagedOmpProviders([channel], {});
   }
 
   _onAfterCreate(_channel, allChannels) {
-    this.syncManagedOmpProvidersIfEnabled(allChannels);
+    this.syncOmpProvidersForCurrentMode(allChannels);
   }
 
   _onAfterUpdate(_oldChannel, _newChannel, allChannels) {
-    this.syncManagedOmpProvidersIfEnabled(allChannels);
+    this.syncOmpProvidersForCurrentMode(allChannels);
   }
 
   _onAfterDelete(_channel, allChannels) {
-    this.syncManagedOmpProvidersIfEnabled(allChannels);
+    this.syncOmpProvidersForCurrentMode(allChannels);
   }
 
-  syncManagedOmpProvidersIfEnabled(channels = this.getChannels().channels) {
-    if (!isManagedOmpModeEnabled()) {
-      return getLastManagedOmpSyncResult();
+  syncOmpProvidersForCurrentMode(channels = this.getChannels().channels) {
+    if (isManagedOmpModeEnabled()) {
+      const state = loadManagedOmpModeState();
+      return this.syncManagedOmpProviders(channels, state?.gateway ? {
+        gateway: state.gateway,
+        activeChannelId: state.activeChannelId
+      } : {});
     }
-    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, options = {}) {
@@ -181,8 +252,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.syncManagedOmpProvidersIfEnabled(channels);
+    return this.syncOmpProvidersForCurrentMode(channels);
   }
 
   disableManagedProviderExtension() {
@@ -209,6 +317,24 @@ function getOriginalOmpProviderId(providerId = '') {
   return normalized.startsWith('ctx-') ? normalized.slice(4) : normalized;
 }
 
+function isManagedOmpProviderId(providerId = '') {
+  return String(providerId || '').trim().startsWith('ctx-');
+}
+
+function isGeneratedOmpApiKey(value = '') {
+  return /^ctx_[a-f0-9]{40}$/i.test(String(value || '').trim());
+}
+
+function isGeneratedOmpBaseUrl(value = '') {
+  const raw = String(value || '').trim();
+  if (!isLocalProxyBaseUrl(raw)) return false;
+  try {
+    return /^\/omp\/[a-f0-9]{24}(?:\/|$)/i.test(new URL(raw).pathname);
+  } catch {
+    return false;
+  }
+}
+
 function normalizeOmpModelId(value = '') {
   return String(value || '').trim().replace(OMP_THINKING_SUFFIX_RE, '');
 }
@@ -297,6 +423,28 @@ function collectOmpSyncSelections(modelsConfig = {}, settings = {}) {
   return [...selections.values()];
 }
 
+function findOmpOriginalProvider(providers = {}, providerId = '') {
+  const normalizedProviderId = normalizeProviderId(getOriginalOmpProviderId(providerId));
+  const candidates = Object.entries(providers)
+    .filter(([key]) => !isManagedOmpProviderId(key))
+    .map(([id, provider]) => ({
+      id,
+      provider,
+      normalizedId: normalizeProviderId(id)
+    }));
+  const exactMatches = candidates.filter(item => item.normalizedId === normalizedProviderId);
+  if (exactMatches.length === 1) return exactMatches[0];
+  if (exactMatches.length > 1) return null;
+
+  const prefixMatches = candidates
+    .filter(item => normalizedProviderId.startsWith(`${item.normalizedId}-`))
+    .sort((left, right) => right.normalizedId.length - left.normalizedId.length);
+  if (prefixMatches.length === 0) return null;
+  const longestLength = prefixMatches[0].normalizedId.length;
+  const longestMatches = prefixMatches.filter(item => item.normalizedId.length === longestLength);
+  return longestMatches.length === 1 ? longestMatches[0] : null;
+}
+
 function findOmpExistingChannel(channels = [], providerId = '', baseUrl = '') {
   const rawProvider = String(providerId || '').trim();
   const originalProvider = getOriginalOmpProviderId(rawProvider);
@@ -386,9 +534,18 @@ function readOmpApiKeyCredential(providerId = '') {
   return { value: '', source: '', envName: '' };
 }
 
+function resolveOmpAuthMode(provider = {}, sourceProvider = {}, existing = null) {
+  const rawAuth = String(sourceProvider.auth || provider.auth || '').trim().toLowerCase();
+  if (rawAuth === 'none') return 'none';
+  if (existing?.authMode === 'none') return 'none';
+  if (existing?.authMode === 'oauth') return 'oauth';
+  return 'api_key';
+}
+
 function buildOmpSyncCandidate(modelsConfig, selection, channels) {
+  const providers = getOmpProviders(modelsConfig);
   const providerId = selection?.providerId || '';
-  const provider = modelsConfig?.providers?.[providerId] || null;
+  const provider = providers[providerId] || null;
   if (!provider || typeof provider !== 'object') {
     return {
       skip: true,
@@ -396,14 +553,42 @@ function buildOmpSyncCandidate(modelsConfig, selection, channels) {
     };
   }
 
-  const baseUrl = String(provider.baseUrl || provider.base_url || '').trim();
-  const originalProviderId = getOriginalOmpProviderId(providerId);
-  const existing = findOmpExistingChannel(channels, providerId, baseUrl);
-  let credential = resolveApiKeyValue(provider.apiKey || provider.api_key || '');
+  const managedProvider = isManagedOmpProviderId(providerId);
+  const originalProviderEntry = managedProvider
+    ? findOmpOriginalProvider(providers, providerId)
+    : null;
+  const sourceProvider = originalProviderEntry?.provider || (managedProvider ? {} : provider);
+  const originalProviderId = originalProviderEntry?.id || getOriginalOmpProviderId(providerId);
+  const providerBaseUrl = String(sourceProvider.baseUrl || sourceProvider.base_url || '').trim();
+  const managedBaseUrl = String(provider.baseUrl || provider.base_url || '').trim();
+  const existing = findOmpExistingChannel(
+    channels,
+    originalProviderId || providerId,
+    managedProvider ? '' : managedBaseUrl
+  );
+  const baseUrl = managedProvider && (
+    !providerBaseUrl || isGeneratedOmpBaseUrl(providerBaseUrl)
+  )
+    ? existing?.baseUrl || ''
+    : providerBaseUrl || existing?.baseUrl || managedBaseUrl;
+  const authMode = resolveOmpAuthMode(provider, sourceProvider, existing);
+
+  let credential = resolveApiKeyValue(sourceProvider.apiKey || sourceProvider.api_key || '');
   if (!credential.value) {
-    credential = readOmpApiKeyCredential(providerId);
+    credential = readOmpApiKeyCredential(originalProviderId || providerId);
   }
-  const apiKey = credential.value || existing?.apiKey || '';
+  const existingCredential = resolveApiKeyValue(existing?.apiKey || '');
+  const apiKey = credential.value && !isGeneratedOmpApiKey(credential.value)
+    ? credential.value
+    : existingCredential.value && !isGeneratedOmpApiKey(existingCredential.value)
+      ? existingCredential.value
+      : '';
+  if (!credential.value || isGeneratedOmpApiKey(credential.value)) {
+    credential = existingCredential.value && !isGeneratedOmpApiKey(existingCredential.value)
+      ? { ...existingCredential, source: 'existing-channel' }
+      : credential;
+  }
+
   const providerModelIds = collectOmpModelIds(provider);
   const selectedModelIds = Array.isArray(selection?.modelIds) ? selection.modelIds : [];
   const allowedModels = selectedModelIds.length > 0 ? selectedModelIds : providerModelIds;
@@ -412,11 +597,11 @@ function buildOmpSyncCandidate(modelsConfig, selection, channels) {
     || existing?.model
     || allowedModels[0]
     || null;
-  if (!apiKey) {
+  if (!baseUrl || (authMode !== 'none' && !apiKey)) {
     return {
       skip: true,
       channel: existing || null,
-      warning: `OMP 当前 provider "${providerId}" 缺少可解析 API Key，OAuth/登录态渠道不支持同步导入。`
+      warning: `OMP 当前 provider "${providerId}" 缺少可解析的上游 Base URL 或 API Key，OAuth/登录态渠道不支持同步导入。`
     };
   }
 
@@ -424,11 +609,11 @@ function buildOmpSyncCandidate(modelsConfig, selection, channels) {
     name: existing?.name || originalProviderId || providerId,
     providerKey: originalProviderId || providerId,
     baseUrl,
-    apiKey,
-    providerApi: normalizeProviderApi(provider.api),
-    wireApi: provider.api || 'openai-completions',
-    authMode: 'api_key',
-    oauthProviderId: '',
+    apiKey: authMode === 'none' ? '' : apiKey,
+    providerApi: normalizeProviderApi(sourceProvider.api || provider.api),
+    wireApi: sourceProvider.api || provider.api || 'openai-completions',
+    authMode,
+    oauthProviderId: authMode === 'oauth' ? (existing?.oauthProviderId || originalProviderId || providerId) : '',
     model: preferredModel,
     allowedModels,
     models: filterOmpProviderModels(provider.models, allowedModels),
@@ -486,6 +671,7 @@ 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, options) => service.syncManagedOmpProviders(channels, options),
@@ -493,6 +679,7 @@ module.exports = {
   syncManagedProviderExtension: (channels) => service.syncManagedProviderExtension(channels),
   disableManagedProviderExtension: () => service.disableManagedProviderExtension(),
   isManagedOmpModeEnabled,
+  getOrCreateOmpGatewaySecret,
   enableManagedOmpMode,
   disableManagedOmpMode,
   loadManagedOmpModeState,

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

@@ -5,6 +5,11 @@ const yaml = require('js-yaml');
 const { HOME_DIR, PATHS = {} } = require('../../config/paths');
 
 const DEFAULT_OMP_COMMAND = 'omp';
+const YAML_DUMP_OPTIONS = Object.freeze({
+  lineWidth: 120,
+  noRefs: true,
+  sortKeys: false
+});
 
 function expandHome(input = '') {
   const value = String(input || '').trim();
@@ -43,7 +48,9 @@ function getDefaultOmpAgentDir(env = process.env) {
 }
 
 function getFallbackOmpAgentDir(runtime, env = process.env) {
-  const configured = expandHome(env.OMP_CODING_AGENT_DIR || '');
+  const configured = expandHome(
+    env.PI_CODING_AGENT_DIR || env.OMP_CODING_AGENT_DIR || ''
+  );
   if (configured) return configured;
   return getDefaultOmpAgentDir(env);
 }
@@ -121,6 +128,14 @@ function ensureOmpDir(dirPath) {
   }
 }
 
+function isPlainObject(value) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
 function readJsonFile(filePath, fallback = {}) {
   try {
     if (!fs.existsSync(filePath)) return fallback;
@@ -150,11 +165,7 @@ function readYamlFile(filePath, fallback = {}) {
 
 function writeYamlFile(filePath, data) {
   ensureOmpDir(path.dirname(filePath));
-  fs.writeFileSync(filePath, yaml.dump(data || {}, {
-    lineWidth: 120,
-    noRefs: true,
-    sortKeys: false
-  }), 'utf8');
+  fs.writeFileSync(filePath, yaml.dump(data || {}, YAML_DUMP_OPTIONS), 'utf8');
 }
 
 function readOmpSettings() {
@@ -166,6 +177,58 @@ function writeOmpSettings(settings) {
   writeYamlFile(getOmpPaths().settings, settings || {});
 }
 
+function readOmpSettingsStrict() {
+  const filePath = getOmpPaths().settings;
+  let source;
+  try {
+    source = fs.readFileSync(filePath, 'utf8');
+  } catch (error) {
+    if (error?.code === 'ENOENT') return {};
+    throw error;
+  }
+
+  const settings = yaml.load(source);
+  if (!isPlainObject(settings)) {
+    throw new Error('Invalid OMP config');
+  }
+  return settings;
+}
+
+function writeOmpSettingsAtomic(settings) {
+  const filePath = getOmpPaths().settings;
+  const directory = path.dirname(filePath);
+  ensureOmpDir(directory);
+  let mode = 0o600;
+  try {
+    mode = fs.statSync(filePath).mode & 0o777;
+  } catch (error) {
+    if (error?.code !== 'ENOENT') throw error;
+  }
+  const temporaryPath = path.join(
+    directory,
+    `.${path.basename(filePath)}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`
+  );
+
+  try {
+    fs.writeFileSync(temporaryPath, yaml.dump(settings, YAML_DUMP_OPTIONS), {
+      encoding: 'utf8',
+      flag: 'wx',
+      mode
+    });
+    fs.chmodSync(temporaryPath, mode);
+    fs.renameSync(temporaryPath, filePath);
+  } catch (error) {
+    try {
+      if (fs.existsSync(temporaryPath)) {
+        fs.unlinkSync(temporaryPath);
+      }
+    } catch {
+      // Preserve the original write, chmod, or rename failure.
+    }
+    throw error;
+  }
+}
+
 function getOmpCommand(env = process.env) {
   return String(env.OMP_COMMAND || DEFAULT_OMP_COMMAND).trim() || DEFAULT_OMP_COMMAND;
 }
@@ -286,6 +349,8 @@ module.exports = {
   writeYamlFile,
   readOmpSettings,
   writeOmpSettings,
+  readOmpSettingsStrict,
+  writeOmpSettingsAtomic,
   getOmpCommand,
   getOmpProfile,
   resolveOmpRuntime,