coding-tool-x 3.8.8 → 3.8.10

package/src/platforms/drivers/gemini/channels-implementation.js

@@ -3,8 +3,9 @@ const path = require('path');
 const crypto = require('crypto');
 const { PATHS, NATIVE_PATHS } = require('../../../config/paths');
 const { resolveChannelWebsiteUrl } = require('../../../config/channel-preset-websites');
-const { clearNativeOAuth, readNativeOAuth, clearGeminiChannelConfig } = require('../../native-oauth-adapters');
+const { readNativeOAuth, clearGeminiChannelConfig } = require('../../native-oauth-adapters');
 const { normalizeGatewaySourceType } = require('../../../shared/proxy-utils');
+const { readJsoncFile, updateJsoncFile, updateEnvFile } = require('../../../utils/native-config-patcher');
 const {
   createSkippedResult,
   isLocalProxyBaseUrl,
@@ -84,12 +85,16 @@ function applyNativeGeminiOAuth(channel) {
   clearGeminiChannelConfig();
 
   const settingsPath = configuredNative.settings;
-  const settings = readGeminiSettings();
-  settings.security = settings.security || {};
-  settings.security.auth = settings.security.auth || {};
-  settings.security.auth.selectedType = 'oauth-personal';
-  fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
-  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+  updateJsoncFile(settingsPath, (settings) => {
+    settings.security = settings.security && typeof settings.security === 'object' && !Array.isArray(settings.security)
+      ? settings.security
+      : {};
+    settings.security.auth = settings.security.auth && typeof settings.security.auth === 'object'
+      && !Array.isArray(settings.security.auth)
+      ? settings.security.auth
+      : {};
+    settings.security.auth.selectedType = 'oauth-personal';
+  });
   console.log(`[Gemini Channels] Applied native OAuth channel ${channel.name}`);
   return channel;
 }
@@ -168,14 +173,11 @@ function readExistingGeminiEnv() {
 
 function writeGeminiEnv(env = {}) {
   const envPath = path.join(getGeminiDir(), '.env');
-  const content = Object.entries(env)
-    .map(([key, value]) => `${key}=${value}`)
-    .join('\n');
-
-  fs.writeFileSync(envPath, content ? `${content}\n` : '', 'utf8');
-  if (process.platform !== 'win32') {
-    fs.chmodSync(envPath, 0o600);
-  }
+  const managedKeys = ['GOOGLE_GEMINI_BASE_URL', 'GEMINI_API_KEY', 'GEMINI_MODEL'];
+  updateEnvFile(envPath, Object.fromEntries(managedKeys.map(key => [
+    key,
+    Object.prototype.hasOwnProperty.call(env, key) ? env[key] : undefined
+  ])), { atomic: true, mode: 0o600 });
 }
 
 // 检查是否在代理模式
@@ -515,8 +517,6 @@ function applyChannelToSettings(channelId, channels = null) {
     return applyNativeGeminiOAuth(channel);
   }
 
-  clearNativeOAuth('gemini');
-
   const geminiDir = getGeminiDir();
 
   if (!fs.existsSync(geminiDir)) {
@@ -532,22 +532,16 @@ function applyChannelToSettings(channelId, channels = null) {
 
   // 确保 settings.json 存在并配置正确的认证模式
   const settingsPath = path.join(geminiDir, 'settings.json');
-  let settings = {};
-
-  if (fs.existsSync(settingsPath)) {
-    try {
-      settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-    } catch (err) {
-      console.warn('[Gemini Channels] Failed to read settings.json, creating new');
-    }
-  }
-
-  // 设置认证模式为 gemini-api-key（第三方 API）
-  settings.security = settings.security || {};
-  settings.security.auth = settings.security.auth || {};
-  settings.security.auth.selectedType = 'gemini-api-key';
-
-  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+  updateJsoncFile(settingsPath, (settings) => {
+    settings.security = settings.security && typeof settings.security === 'object' && !Array.isArray(settings.security)
+      ? settings.security
+      : {};
+    settings.security.auth = settings.security.auth && typeof settings.security.auth === 'object'
+      && !Array.isArray(settings.security.auth)
+      ? settings.security.auth
+      : {};
+    settings.security.auth.selectedType = 'gemini-api-key';
+  });
 
   console.log(`[Gemini Channels] Applied channel ${channel.name} to .env`);
   return channel;
@@ -600,6 +594,17 @@ function writeGeminiConfigForMultiChannel(allChannels) {
     delete env.GEMINI_API_KEY;
     delete env.GEMINI_MODEL;
     writeGeminiEnv(env);
+    const settingsPath = path.join(geminiDir, 'settings.json');
+    if (fs.existsSync(settingsPath)) {
+      updateJsoncFile(settingsPath, (settings) => {
+        const auth = settings.security?.auth;
+        if (auth?.selectedType === 'gemini-api-key') {
+          delete auth.selectedType;
+          if (Object.keys(auth).length === 0) delete settings.security.auth;
+          if (Object.keys(settings.security).length === 0) delete settings.security;
+        }
+      });
+    }
     return;
   }
 
@@ -611,22 +616,13 @@ function writeGeminiConfigForMultiChannel(allChannels) {
 
   // 确保 settings.json 存在并配置正确的认证模式
   const settingsPath = path.join(geminiDir, 'settings.json');
-  let settings = {};
-
-  if (fs.existsSync(settingsPath)) {
-    try {
-      settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-    } catch (err) {
-      console.warn('[Gemini Channels] Failed to read settings.json, creating new');
-    }
-  }
-
-  // 设置认证模式为 gemini-api-key（第三方 API）
-  settings.security = settings.security || {};
-  settings.security.auth = settings.security.auth || {};
-  settings.security.auth.selectedType = 'gemini-api-key';
-
-  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+  updateJsoncFile(settingsPath, (settings) => {
+    settings.security = settings.security && typeof settings.security === 'object' ? settings.security : {};
+    settings.security.auth = settings.security.auth && typeof settings.security.auth === 'object'
+      ? settings.security.auth
+      : {};
+    settings.security.auth.selectedType = 'gemini-api-key';
+  });
 }
 
 // 获取所有启用的渠道（供调度器使用）
@@ -682,7 +678,7 @@ function disableAllChannels() {
   data.channels.forEach(ch => { ch.enabled = false; });
   saveChannels(data);
   if (!getGeminiProxyState().running) {
-    clearGeminiChannelConfig();
+    writeGeminiConfigForMultiChannel(data.channels);
   }
 }
 
@@ -691,11 +687,7 @@ function readGeminiSettings() {
   if (!settingsPath || !fs.existsSync(settingsPath)) {
     return {};
   }
-  try {
-    return JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-  } catch {
-    return {};
-  }
+  return readJsoncFile(settingsPath);
 }
 
 function normalizeGeminiChannel(channel = {}) {

package/src/platforms/drivers/gemini/native-config-implementation.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const { NATIVE_PATHS } = require('../../../config/paths');
+const { readJsoncFile, writeJsoncFile, updateEnvFile } = require('../../../utils/native-config-patcher');
 const DEFAULT_NATIVE_PATHS = NATIVE_PATHS.gemini;
 let nativePaths = DEFAULT_NATIVE_PATHS;
 
@@ -64,25 +65,14 @@ function readEnv() {
   }
 }
 
-// 将环境对象转换为 .env 字符串
-function envToString(env) {
-  let content = '';
-  for (const [key, value] of Object.entries(env)) {
-    content += `${key}=${value}\n`;
-  }
-  return content;
-}
-
 // 写入 .env
 function writeEnv(env) {
   try {
-    const content = envToString(env);
-    fs.writeFileSync(getEnvPath(), content, 'utf8');
-
-    // 设置文件权限为 600 (仅所有者可读写)
-    if (process.platform !== 'win32') {
-      fs.chmodSync(getEnvPath(), 0o600);
-    }
+    const managedKeys = ['GOOGLE_GEMINI_BASE_URL', 'GEMINI_API_KEY', 'GEMINI_MODEL'];
+    updateEnvFile(getEnvPath(), Object.fromEntries(managedKeys.map(key => [
+      key,
+      Object.prototype.hasOwnProperty.call(env || {}, key) ? env[key] : undefined
+    ])), { atomic: true, mode: 0o600 });
   } catch (err) {
     throw new Error('Failed to write .env: ' + err.message);
   }
@@ -94,8 +84,7 @@ function readSettings() {
     if (!settingsExists()) {
       return {};
     }
-    const content = fs.readFileSync(getSettingsPath(), 'utf8');
-    return JSON.parse(content);
+    return readJsoncFile(getSettingsPath());
   } catch (err) {
     throw new Error('Failed to read settings.json: ' + err.message);
   }
@@ -104,8 +93,7 @@ function readSettings() {
 // 写入 settings.json
 function writeSettings(settings) {
   try {
-    const content = JSON.stringify(settings, null, 2);
-    fs.writeFileSync(getSettingsPath(), content, 'utf8');
+    writeJsoncFile(getSettingsPath(), settings);
   } catch (err) {
     throw new Error('Failed to write settings.json: ' + err.message);
   }

package/src/platforms/drivers/generic-native-config.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const { createNativeSnapshotMethods } = require('./native-config-snapshot');
+
+function createDriver(context = {}) {
+  return {
+    platform: context.platform,
+    capability: 'nativeConfig',
+    ...context,
+    ...createNativeSnapshotMethods({}, {
+      platform: context.platform,
+      runtime: context.runtime,
+      manifest: context.manifest,
+      pathContext: context.pathContext,
+      paths: context.paths
+    })
+  };
+}
+
+module.exports = { createDriver };

package/src/platforms/drivers/native-config-snapshot.js

@@ -83,17 +83,43 @@ function writeEntry(spec, entry, overwrite) {
   return 'success';
 }
 
-function createNativeSnapshotMethods(specs, { platform, runtime } = {}) {
+function resolveSnapshotPath(spec, { pathContext, paths, manifest } = {}) {
+  const rawPath = typeof spec?.path === 'string' ? spec.path.trim() : '';
+  if (!rawPath) return null;
+
+  const nativePaths = pathContext?.native || paths || {};
+  if (typeof nativePaths[rawPath] === 'string' && nativePaths[rawPath].trim()) {
+    return nativePaths[rawPath];
+  }
+
+  const home = pathContext?.home || nativePaths.home || manifest?.paths?.home || process.cwd();
+  const expanded = rawPath.replace(/\{home\}/g, home);
+  return path.isAbsolute(expanded) ? path.normalize(expanded) : path.resolve(home, expanded);
+}
+
+function resolveNativeSnapshotSpecs(declarations, context = {}) {
+  return Object.fromEntries(Object.entries(declarations || {})
+    .map(([key, spec]) => [key, {
+      ...spec,
+      path: resolveSnapshotPath(spec, context)
+    }])
+    .filter(([, spec]) => spec.path));
+}
+
+function createNativeSnapshotMethods(specs, { platform, runtime, manifest, pathContext, paths } = {}) {
+  const resolvedSpecs = Object.keys(specs || {}).length > 0
+    ? specs
+    : resolveNativeSnapshotSpecs(manifest?.nativeConfigSnapshot, { manifest, pathContext, paths });
   const methods = {
     exportSnapshot() {
-      return Object.fromEntries(Object.entries(specs || {})
+      return Object.fromEntries(Object.entries(resolvedSpecs || {})
         .map(([key, spec]) => [key, readEntry(spec)])
         .filter(([, entry]) => entry));
     },
     importSnapshot(snapshot = {}, { overwrite = true } = {}) {
       const result = { success: 0, imported: 0, skipped: 0, failed: 0 };
       for (const [key, entry] of Object.entries(snapshot || {})) {
-        const status = writeEntry(specs[key], entry, overwrite);
+        const status = writeEntry(resolvedSpecs[key], entry, overwrite);
         if (status === 'success') {
           result.success += 1;
           result.imported += 1;
@@ -122,4 +148,4 @@ function createNativeSnapshotMethods(specs, { platform, runtime } = {}) {
   return methods;
 }
 
-module.exports = { createNativeSnapshotMethods };
+module.exports = { createNativeSnapshotMethods, resolveNativeSnapshotSpecs };

package/src/platforms/drivers/omp/channels-implementation.js

@@ -10,6 +10,7 @@ const {
   writeManagedOmpProviders,
   removeManagedOmpProviders,
   getLastManagedOmpSyncResult,
+  getManagedProviderId,
   readModelsConfig,
   readOmpSettingsConfig,
   normalizeProviderId,
@@ -59,6 +60,15 @@ function selectLatestEnabledChannel(channels = []) {
   }, enabledChannels[0]);
 }
 
+function getChannelManagedProviderId(channel = {}) {
+  if (typeof getManagedProviderId === 'function') {
+    return getManagedProviderId(channel);
+  }
+  const rawId = channel.managedProviderId || channel.providerKey || channel.provider || channel.name || channel.id;
+  const normalizedId = normalizeProviderId(rawId);
+  return normalizedId.startsWith('ctx-') ? normalizedId : `ctx-${normalizedId}`;
+}
+
 function loadManagedOmpModeState() {
   ensureStorageDirMigrated();
   try {
@@ -269,16 +279,24 @@ class OmpChannelService extends BaseChannelService {
   }
 
   _applyToNativeSettings(channel) {
+    const knownProviderIds = this.getChannels().channels.map(getChannelManagedProviderId);
     if (isManagedOmpModeEnabled()) {
       const state = loadManagedOmpModeState();
       enableManagedOmpMode(channel.id, state?.gateway || null);
       writeManagedOmpProviders([channel], state?.gateway ? {
         gateway: state.gateway,
-        activeChannelId: channel.id
-      } : {});
+        activeChannelId: channel.id,
+        knownProviderIds
+      } : { knownProviderIds });
       return;
     }
-    writeManagedOmpProviders([channel], {});
+    writeManagedOmpProviders([channel], { knownProviderIds });
+  }
+
+  disableAllChannels() {
+    const result = super.disableAllChannels();
+    this.syncOmpProvidersForCurrentMode(this.getChannels().channels);
+    return result;
   }
 
   _onAfterCreate(_channel, allChannels) {
@@ -296,13 +314,18 @@ class OmpChannelService extends BaseChannelService {
   syncOmpProvidersForCurrentMode(channels = this.getChannels().channels) {
     if (isManagedOmpModeEnabled()) {
       const state = loadManagedOmpModeState();
-      return this.syncManagedOmpProviders(channels, state?.gateway ? {
-        gateway: state.gateway,
-        activeChannelId: state.activeChannelId
-      } : {});
+      return this.syncManagedOmpProviders(channels, {
+        ...(state?.gateway ? {
+          gateway: state.gateway,
+          activeChannelId: state.activeChannelId
+        } : {}),
+        knownProviderIds: channels.map(getChannelManagedProviderId)
+      });
     }
     const activeChannel = selectLatestEnabledChannel(channels);
-    return this.syncManagedOmpProviders(activeChannel ? [activeChannel] : [], {});
+    return this.syncManagedOmpProviders(activeChannel ? [activeChannel] : [], {
+      knownProviderIds: channels.map(getChannelManagedProviderId)
+    });
   }
 
   syncManagedOmpProviders(channels = this.getChannels().channels, options = {}) {
@@ -335,7 +358,9 @@ class OmpChannelService extends BaseChannelService {
 
     try {
       this.saveChannels(data);
-      const sync = this.syncManagedOmpProviders([channel], {});
+      const sync = this.syncManagedOmpProviders([channel], {
+        knownProviderIds: data.channels.map(getChannelManagedProviderId)
+      });
       if (!wasEnabled) {
         clearOmpChannelBalanceCache(channel);
       }
@@ -739,24 +764,33 @@ function getCatalogMetadata({
       ))
       : [])
   ]
-    .map(value => String(value || '').trim().toLowerCase())
-    .filter(Boolean);
+    .map(value => String(value || '').trim())
+    .filter(Boolean)
+    .filter((value, index, values) => values.findIndex(item => item.toLowerCase() === value.toLowerCase()) === index);
   const normalizedProviderKey = String(providerKey || '').trim().toLowerCase();
 
   const allEntries = Object.entries(MODEL_METADATA)
     .filter(([, metadata]) => Array.isArray(metadata.toolTypes) && metadata.toolTypes.includes('omp'))
     .map(([id, metadata]) => ({ ...structuredClone(metadata), id }));
 
-  const matchesRequestedId = entry => requestedIds.length > 0 && requestedIds.some(requested => (
-    requested === entry.id.toLowerCase()
-      || requested === String(entry.sourceId || '').toLowerCase()
-      || requested === entry.id.split('/').pop().toLowerCase()
-  ));
+  const findRequestedEntry = requestedId => allEntries.find(entry => {
+    const normalizedRequestedId = requestedId.toLowerCase();
+    return normalizedRequestedId === entry.id.toLowerCase()
+      || normalizedRequestedId === String(entry.sourceId || '').toLowerCase()
+      || normalizedRequestedId === entry.id.split('/').pop().toLowerCase();
+  });
   const matchesProvider = entry => (
     String(entry.provider || '').toLowerCase() === normalizedProviderKey
     || String(entry.sourceId || '').toLowerCase().startsWith(`${normalizedProviderKey}/`)
   );
-  const requestedEntries = requestedIds.length > 0 ? allEntries.filter(matchesRequestedId) : [];
+  const requestedEntries = requestedIds.length > 0
+    ? requestedIds
+      .map(requestedId => {
+        const entry = findRequestedEntry(requestedId);
+        return entry ? { ...entry, id: requestedId } : null;
+      })
+      .filter(Boolean)
+    : [];
   const providerEntries = normalizedProviderKey ? allEntries.filter(matchesProvider) : [];
   const entries = requestedIds.length > 0 ? requestedEntries : providerEntries;
 

package/src/platforms/drivers/omp/native-config-implementation.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const yaml = require('js-yaml');
+const { writeYamlFile } = require('../../../utils/native-config-patcher');
 const ompConfig = require('./config');
 const { prepareManagedOmpChannels } = require('./gateway-routing');
 const { MODEL_METADATA, MODEL_ALIASES } = require('../../../config/model-metadata');
@@ -409,13 +410,7 @@ function readModelsConfig(filePath = getOmpPaths().modelsYml) {
 }
 
 function writeModelsConfig(config, filePath = getOmpPaths().modelsYml) {
-  ensureOmpDir(path.dirname(filePath));
-  const doc = yaml.dump(config || { providers: {} }, {
-    lineWidth: 120,
-    noRefs: true,
-    sortKeys: false
-  });
-  writeFileAtomic(filePath, doc);
+  writeYamlFile(filePath, config || { providers: {} }, { atomic: true });
 }
 
 function getOmpSettingsPath(paths = getOmpPaths()) {
@@ -447,13 +442,7 @@ function readOmpSettingsConfig(filePath = getOmpSettingsPath()) {
 }
 
 function writeOmpSettingsConfig(config, filePath = getOmpSettingsPath()) {
-  ensureOmpDir(path.dirname(filePath));
-  const doc = yaml.dump(config || {}, {
-    lineWidth: 120,
-    noRefs: true,
-    sortKeys: false
-  });
-  writeFileAtomic(filePath, doc);
+  writeYamlFile(filePath, config || {}, { atomic: true });
 }
 
 function getModelsBackupPrefix(filePath) {
@@ -669,9 +658,10 @@ function removeLegacyManagedExtension(paths = getOmpPaths()) {
   }
 }
 
-function pruneManagedProviders(providers = {}) {
+function pruneManagedProviders(providers = {}, knownProviderIds = null) {
+  const keep = knownProviderIds instanceof Set ? knownProviderIds : null;
   Object.keys(providers).forEach((providerId) => {
-    if (isManagedProviderId(providerId)) {
+    if (isManagedProviderId(providerId) && (!keep || !keep.has(providerId))) {
       delete providers[providerId];
     }
   });
@@ -684,7 +674,10 @@ function buildManagedModelsConfig(channels = [], baseConfig = readModelsConfig()
       ...(baseConfig.providers || {})
     }
   };
-  pruneManagedProviders(next.providers);
+  const knownProviderIds = Array.isArray(options.knownProviderIds)
+    ? new Set(options.knownProviderIds)
+    : new Set((channels || []).map(getManagedProviderId));
+  pruneManagedProviders(next.providers, knownProviderIds);
 
   channels
     .filter(channel => channel && channel.enabled !== false && channel.baseUrl)

package/src/platforms/drivers/omp/prompts.js

@@ -1,9 +1,65 @@
 'use strict';
 
-const { createPromptDriver } = require('../../../shared/driver-factories/prompts');
+const fs = require('fs');
+const path = require('path');
+const { ok, failed } = require('../../../shared/driver-result');
+const { getOmpPaths } = require('./config');
+
+const MANAGED_PROMPT_NAMESPACE = 'coding-tool-x';
+const MANAGED_PROMPT_FILE = 'prompt.md';
+
+function resolvePromptsDir(context = {}) {
+  const native = context.pathContext?.native || {};
+  return native.prompts
+    || context.paths?.prompts
+    || getOmpPaths(process.env, { resolveRuntime: false }).prompts;
+}
+
+function stripFrontmatter(content) {
+  return String(content || '').replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n(?:\r?\n)?/, '');
+}
+
+function buildTemplateContent(content) {
+  return `---\ndescription: "coding-tool-x prompt"\n---\n\n${content}`;
+}
 
 function createDriver(context = {}) {
-  return createPromptDriver({ ...context, platform: 'omp' });
+  const promptsDir = resolvePromptsDir(context);
+  const managedDir = path.join(promptsDir, MANAGED_PROMPT_NAMESPACE);
+  const promptPath = path.join(managedDir, MANAGED_PROMPT_FILE);
+
+  const invoke = (operation, args) => {
+    try {
+      if (operation === 'read') {
+        return ok('omp', 'prompts', operation,
+          fs.existsSync(promptPath) ? stripFrontmatter(fs.readFileSync(promptPath, 'utf8')) : '');
+      }
+
+      if (operation === 'write') {
+        const [content] = args;
+        if (typeof content !== 'string') throw new Error('提示词内容必须是字符串');
+        fs.mkdirSync(managedDir, { recursive: true });
+        fs.writeFileSync(promptPath, buildTemplateContent(content), 'utf8');
+        return ok('omp', 'prompts', operation, content);
+      }
+
+      if (fs.existsSync(managedDir)) {
+        fs.rmSync(managedDir, { recursive: true, force: true });
+      }
+      return ok('omp', 'prompts', operation, true);
+    } catch (error) {
+      return failed('omp', 'prompts', operation, error);
+    }
+  };
+
+  return {
+    platform: 'omp',
+    capability: 'prompts',
+    path: managedDir,
+    read: (...args) => invoke('read', args),
+    write: (...args) => invoke('write', args),
+    remove: (...args) => invoke('remove', args)
+  };
 }
 
 module.exports = { createDriver };

package/src/platforms/drivers/omp/proxy-implementation.js

@@ -15,6 +15,7 @@ const {
 const { createOmpGateway } = require('./gateway');
 const { prepareManagedOmpChannels } = require('./gateway-routing');
 const { probeOmpAuthGateways } = require('./auth-gateway-client');
+const { restoreStoredOmpOAuthCredentials } = require('../../oauth-credentials-service');
 
 let currentPort = null;
 let lastSyncResult = null;
@@ -33,11 +34,24 @@ function withLifecycleLock(operation) {
 
 async function startOmpProxyServerUnlocked(options = {}) {
   if (gateway.status().listening) {
+    const oauthRestore = restoreStoredOmpOAuthCredentials(getEnabledChannels());
+    if (oauthRestore.warnings.length > 0) {
+      lastSyncResult = {
+        ...(lastSyncResult || {}),
+        warnings: [
+          ...(lastSyncResult?.warnings || []),
+          ...oauthRestore.warnings
+        ]
+      };
+    }
     return {
       success: true,
       port: gateway.status().port,
       sync: lastSyncResult,
-      warnings: lastSyncResult?.warnings || []
+      warnings: [
+        ...(lastSyncResult?.warnings || []),
+        ...(oauthRestore.warnings || [])
+      ]
     };
   }
   const preserveStartTime = options.preserveStartTime || false;
@@ -56,6 +70,7 @@ async function startOmpProxyServerUnlocked(options = {}) {
   });
   currentPort = gatewayStatus.port;
   try {
+    const oauthRestore = restoreStoredOmpOAuthCredentials(channels);
     const oauthSupport = await probeOmpAuthGateways(channels);
     const descriptor = {
       ...gateway.descriptor(),
@@ -71,10 +86,19 @@ async function startOmpProxyServerUnlocked(options = {}) {
       lastSyncResult = {
         ...lastSyncResult,
         warnings: [
+          ...(oauthRestore.warnings || []),
           ...(lastSyncResult?.warnings || []),
           ...oauthSupport.warnings
         ]
       };
+    } else if (oauthRestore.warnings.length > 0) {
+      lastSyncResult = {
+        ...lastSyncResult,
+        warnings: [
+          ...(oauthRestore.warnings || []),
+          ...(lastSyncResult?.warnings || [])
+        ]
+      };
     }
   } catch (error) {
     if (wasEnabled) {