coding-tool-x 3.6.13 → 3.7.1

package/src/server/services/config-export-service.js

@@ -8,11 +8,13 @@ const path = require('path');
 const AdmZip = require('adm-zip');
 const toml = require('toml');
 const tomlStringify = require('@iarna/toml').stringify;
+const yaml = require('js-yaml');
 const configTemplatesService = require('./config-templates-service');
 const channelsService = require('./channels');
 const codexChannelsService = require('./codex-channels');
 const geminiChannelsService = require('./gemini-channels');
 const opencodeChannelsService = require('./opencode-channels');
+const ompChannelsService = require('./omp-channels');
 const { AgentsService } = require('./agents-service');
 const { CommandsService } = require('./commands-service');
 const { SkillService } = require('./skill-service');
@@ -23,12 +25,16 @@ const CONFIG_VERSION = '1.4.0';
 const SKILL_FILE_ENCODING = 'base64';
 const SKILL_IGNORE_DIRS = new Set(['.git']);
 const SKILL_IGNORE_FILES = new Set(['.DS_Store']);
+const NATIVE_DIR_FILE_ENCODING = 'base64';
+const NATIVE_DIR_IGNORE_DIRS = new Set(['.git']);
+const NATIVE_DIR_IGNORE_FILES = new Set(['.DS_Store']);
 const CC_TOOL_DIR = PATHS.base;
 const LEGACY_CC_TOOL_DIR = PATHS.base;
 const CLAUDE_SETTINGS_PATH = NATIVE_PATHS.claude.settings;
 const LEGACY_PLUGINS_DIR = path.join(LEGACY_CC_TOOL_DIR, 'plugins', 'installed');
 const LEGACY_PLUGINS_REGISTRY = path.join(LEGACY_CC_TOOL_DIR, 'plugins', 'registry.json');
-const CLAUDE_PLUGINS_DIR = path.join(path.dirname(NATIVE_PATHS.claude.settings), 'plugins');
+const CLAUDE_PLUGINS_DIR = NATIVE_PATHS.claude.plugins
+  || path.join(NATIVE_PATHS.claude.dir || path.dirname(NATIVE_PATHS.claude.settings), 'plugins');
 const NATIVE_PLUGINS_REGISTRY = path.join(CLAUDE_PLUGINS_DIR, 'installed_plugins.json');
 const PLUGIN_IGNORE_DIRS = new Set(['.git', 'node_modules', '.DS_Store']);
 const PLUGIN_IGNORE_FILES = new Set(['.DS_Store']);
@@ -49,16 +55,59 @@ const LEGACY_UI_CONFIG_PATH = PATHS.uiConfig;
 const LEGACY_NOTIFY_HOOK_PATH = PATHS.notifyHook;
 const GEMINI_SETTINGS_PATH = path.join(path.dirname(NATIVE_PATHS.gemini.env), 'settings.json');
 const AGENT_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode'];
-const COMMAND_PLATFORMS = ['claude', 'gemini', 'opencode'];
-const SKILL_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode'];
-const PLUGIN_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode', 'pi'];
+const COMMAND_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode', 'omp'];
+const SKILL_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode', 'omp'];
+const PLUGIN_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode', 'omp'];
 const CLAUDE_MARKETPLACES_REGISTRY = path.join(CLAUDE_PLUGINS_DIR, 'known_marketplaces.json');
 const CODEX_PLUGINS_DIR = path.join(path.dirname(NATIVE_PATHS.codex.config), 'plugins');
 const CODEX_PLUGINS_CACHE_DIR = path.join(CODEX_PLUGINS_DIR, 'cache');
 const OPENCODE_PLUGINS_DIR = path.join(NATIVE_PATHS.opencode.config, 'plugins');
 const OPENCODE_LEGACY_PLUGINS_DIR = path.join(NATIVE_PATHS.opencode.config, 'plugin');
-const PI_SETTINGS_PATH = NATIVE_PATHS.pi?.settings || path.join(PATHS.base, 'pi-settings.json');
-const PI_EXTENSIONS_DIR = NATIVE_PATHS.pi?.extensions || path.join(PATHS.base, 'pi-extensions');
+const OMP_SETTINGS_PATH = NATIVE_PATHS.omp?.settings || path.join(PATHS.base, 'omp-config.yml');
+const OMP_EXTENSIONS_DIR = NATIVE_PATHS.omp?.extensions || path.join(PATHS.base, 'omp-extensions');
+
+function normalizeOmpResourceType(value = '') {
+  const key = String(value || '').trim().replace(/[\s_-]+/g, '').toLowerCase();
+  const map = {
+    extension: 'extension',
+    extensions: 'extension',
+    plugin: 'extension',
+    plugins: 'extension',
+    skill: 'skill',
+    skills: 'skill',
+    prompt: 'promptTemplate',
+    prompts: 'promptTemplate',
+    prompttemplate: 'promptTemplate',
+    prompttemplates: 'promptTemplate',
+    command: 'promptTemplate',
+    commands: 'promptTemplate',
+    theme: 'theme',
+    themes: 'theme',
+    mcp: 'mcp',
+    subagent: 'subagent',
+    subagents: 'subagent'
+  };
+  return map[key] || String(value || '').trim();
+}
+
+function normalizeOmpResourceTypes(input = []) {
+  const result = [];
+  const add = (value) => {
+    const normalized = normalizeOmpResourceType(value);
+    if (normalized && !result.includes(normalized)) result.push(normalized);
+  };
+  if (Array.isArray(input)) {
+    input.forEach(add);
+  } else if (input && typeof input === 'object') {
+    for (const [key, value] of Object.entries(input)) {
+      if (value === false || value == null) continue;
+      add(key);
+    }
+  } else if (input) {
+    add(input);
+  }
+  return result;
+}
 
 function getOpenCodeConfigPaths() {
   try {
@@ -81,6 +130,7 @@ function getOpenCodeNotificationPluginPath() {
 function getNativeConfigSpecs() {
   const openCodeConfigPaths = getOpenCodeConfigPaths();
   const openCodeNotificationPluginPath = getOpenCodeNotificationPluginPath();
+  const ompDir = NATIVE_PATHS.omp.dir || path.dirname(NATIVE_PATHS.omp.settings);
   return {
     claude: {
       settings: { path: NATIVE_PATHS.claude.settings, format: 'json' }
@@ -100,6 +150,19 @@ function getNativeConfigSpecs() {
       ...(openCodeNotificationPluginPath
         ? { codingToolNotifyPlugin: { path: openCodeNotificationPluginPath, format: 'text' } }
         : {})
+    },
+    omp: {
+      settings: { path: NATIVE_PATHS.omp.settings, format: 'yaml' },
+      auth: { path: NATIVE_PATHS.omp.auth, format: 'json', mode: 0o600 },
+      models: { path: NATIVE_PATHS.omp.models, format: 'yaml' },
+      commands: { path: NATIVE_PATHS.omp.commands || path.join(ompDir, 'commands'), format: 'directory' },
+      prompts: { path: NATIVE_PATHS.omp.prompts, format: 'directory' },
+      skills: { path: NATIVE_PATHS.omp.skills, format: 'directory' },
+      extensions: { path: NATIVE_PATHS.omp.extensions, format: 'directory' },
+      themes: { path: NATIVE_PATHS.omp.themes || path.join(ompDir, 'themes'), format: 'directory' },
+      packages: { path: NATIVE_PATHS.omp.packages || path.join(ompDir, 'packages'), format: 'directory' },
+      npmPackages: { path: path.join(ompDir, 'npm'), format: 'directory' },
+      gitPackages: { path: path.join(ompDir, 'git'), format: 'directory' }
     }
   };
 }
@@ -120,6 +183,17 @@ function readJsonFileSafe(filePath) {
   }
 }
 
+function readYamlFileSafe(filePath) {
+  if (!filePath || !fs.existsSync(filePath)) return null;
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const parsed = yaml.load(content);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+  } catch (err) {
+    return null;
+  }
+}
+
 function readTextFileSafe(filePath) {
   if (!filePath || !fs.existsSync(filePath)) return null;
   try {
@@ -135,6 +209,10 @@ function readNativeConfigSnapshot(spec) {
   }
 
   try {
+    if (spec.format === 'directory') {
+      return readNativeDirectorySnapshot(spec.path);
+    }
+
     const rawContent = fs.readFileSync(spec.path, 'utf8');
     if (spec.format === 'json') {
       try {
@@ -152,6 +230,22 @@ function readNativeConfigSnapshot(spec) {
       }
     }
 
+    if (spec.format === 'yaml') {
+      try {
+        return {
+          format: 'yaml',
+          fileName: path.basename(spec.path),
+          content: yaml.load(rawContent) || {}
+        };
+      } catch (err) {
+        return {
+          format: 'text',
+          fileName: path.basename(spec.path),
+          content: rawContent
+        };
+      }
+    }
+
     return {
       format: spec.format || 'text',
       fileName: path.basename(spec.path),
@@ -162,6 +256,61 @@ function readNativeConfigSnapshot(spec) {
   }
 }
 
+function collectNativeDirectoryFiles(baseDir) {
+  const files = [];
+  const stack = [baseDir];
+
+  while (stack.length > 0) {
+    const currentDir = stack.pop();
+    let entries = [];
+    try {
+      entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    } catch (err) {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (NATIVE_DIR_IGNORE_DIRS.has(entry.name)) {
+          continue;
+        }
+        stack.push(path.join(currentDir, entry.name));
+      } else if (entry.isFile()) {
+        if (NATIVE_DIR_IGNORE_FILES.has(entry.name)) {
+          continue;
+        }
+        const fullPath = path.join(currentDir, entry.name);
+        const relativePath = path.relative(baseDir, fullPath);
+        try {
+          const content = fs.readFileSync(fullPath);
+          files.push({
+            path: relativePath,
+            encoding: NATIVE_DIR_FILE_ENCODING,
+            content: content.toString(NATIVE_DIR_FILE_ENCODING)
+          });
+        } catch (err) {
+          continue;
+        }
+      }
+    }
+  }
+
+  files.sort((a, b) => a.path.localeCompare(b.path));
+  return files;
+}
+
+function readNativeDirectorySnapshot(dirPath) {
+  const files = collectNativeDirectoryFiles(dirPath);
+  if (files.length === 0) {
+    return null;
+  }
+  return {
+    format: 'directory',
+    fileName: path.basename(dirPath),
+    files
+  };
+}
+
 function writeJsonFileAbsolute(filePath, data, overwrite, options = {}) {
   if (data === undefined) {
     return 'failed';
@@ -179,6 +328,18 @@ function writeJsonFileAbsolute(filePath, data, overwrite, options = {}) {
   return 'success';
 }
 
+function writeYamlFileAbsolute(filePath, data, overwrite, options = {}) {
+  if (data === undefined) {
+    return 'failed';
+  }
+  return writeTextFileAbsolute(
+    filePath,
+    yaml.dump(data || {}, { lineWidth: 120, noRefs: true, sortKeys: false }),
+    overwrite,
+    options
+  );
+}
+
 function writeTextFileAbsolute(filePath, content, overwrite, options = {}) {
   if (content === undefined || content === null) {
     return 'failed';
@@ -198,6 +359,9 @@ function writeTextFileAbsolute(filePath, content, overwrite, options = {}) {
 
 function writeNativeConfigAbsolute(spec, entry, overwrite) {
   if (!spec?.path || !entry || entry.content === undefined) {
+    if (spec?.format === 'directory' && entry?.files !== undefined) {
+      return writeNativeDirectoryAbsolute(spec.path, entry.files, overwrite);
+    }
     return 'failed';
   }
 
@@ -205,10 +369,56 @@ function writeNativeConfigAbsolute(spec, entry, overwrite) {
   if (format === 'json' && entry.content && typeof entry.content === 'object') {
     return writeJsonFileAbsolute(spec.path, entry.content, overwrite, { mode: spec.mode });
   }
+  if (format === 'yaml' && entry.content && typeof entry.content === 'object') {
+    return writeTextFileAbsolute(
+      spec.path,
+      yaml.dump(entry.content, { lineWidth: 120, noRefs: true, sortKeys: false }),
+      overwrite,
+      { mode: spec.mode }
+    );
+  }
 
   return writeTextFileAbsolute(spec.path, String(entry.content), overwrite, { mode: spec.mode });
 }
 
+function writeNativeDirectoryAbsolute(dirPath, files = [], overwrite) {
+  if (!dirPath || !Array.isArray(files)) {
+    return 'failed';
+  }
+  if (files.length === 0) {
+    return 'skipped';
+  }
+  if (fs.existsSync(dirPath) && !overwrite) {
+    return 'skipped';
+  }
+  if (fs.existsSync(dirPath)) {
+    fs.rmSync(dirPath, { recursive: true, force: true });
+  }
+  ensureDir(dirPath);
+
+  let failed = false;
+  for (const file of files) {
+    const filePath = resolveSafePath(dirPath, file.path);
+    if (!filePath) {
+      failed = true;
+      break;
+    }
+    try {
+      ensureDir(path.dirname(filePath));
+      if (file.encoding === NATIVE_DIR_FILE_ENCODING || file.encoding === SKILL_FILE_ENCODING) {
+        fs.writeFileSync(filePath, Buffer.from(file.content || '', file.encoding));
+      } else {
+        fs.writeFileSync(filePath, file.content || '', file.encoding || 'utf8');
+      }
+    } catch (err) {
+      failed = true;
+      break;
+    }
+  }
+
+  return failed ? 'failed' : 'success';
+}
+
 function getConfigFilePath() {
   try {
     const { getConfigFilePath: resolveConfigPath } = require('../../config/loader');
@@ -231,7 +441,7 @@ function buildExportReadme(exportData) {
 - 插件 (Plugins)
 - MCP 服务器配置
 - OAuth 凭证管理池
-- 各平台原生配置（Claude / Codex / Gemini / OpenCode）
+- 各平台原生配置（Claude / Codex / Gemini / OpenCode / OMP）
 - UI 配置（主题、面板显示、排序等）
 - Prompts 预设
 - 安全配置
@@ -878,6 +1088,8 @@ function exportOpenCodePluginsByPlatform(service) {
           pluginKind: plugin.pluginKind || 'plugin',
           name: plugin.name,
           directory: plugin.directory || plugin.name,
+          installSource: plugin.installSource || plugin.source || plugin.name,
+          resourceTypes: normalizeOmpResourceTypes(plugin.resourceTypes || plugin.resources),
           version: plugin.version || 'latest',
           description: plugin.description || '',
           enabled: plugin.enabled !== false,
@@ -896,13 +1108,13 @@ function exportOpenCodePluginsByPlatform(service) {
   return { plugins, control };
 }
 
-function exportPiPluginsByPlatform(service) {
+function exportOmpPluginsByPlatform(service) {
   const plugins = (service.listPlugins().plugins || [])
     .map((plugin) => {
-      if (plugin.pluginType === 'package' || plugin.source === 'pi-settings') {
+      if (plugin.pluginType === 'package' || plugin.source === 'omp-settings') {
         return {
-          platform: 'pi',
-          type: 'pi-package',
+          platform: 'omp',
+          type: 'omp-package',
           pluginType: 'package',
           pluginKind: plugin.pluginKind || 'package',
           name: plugin.name,
@@ -911,22 +1123,18 @@ function exportPiPluginsByPlatform(service) {
           description: plugin.description || '',
           enabled: plugin.enabled !== false,
           installed: plugin.installed !== false,
-          source: plugin.source || 'pi-settings'
+          source: plugin.source || 'omp-settings'
         };
       }
-      return buildManagedPluginExportItem(plugin, 'pi', PI_EXTENSIONS_DIR, {
-        type: 'pi-extension',
+      return buildManagedPluginExportItem(plugin, 'omp', OMP_EXTENSIONS_DIR, {
+        type: 'omp-extension',
         pluginType: plugin.pluginType || 'extension',
         pluginKind: plugin.pluginKind || 'extension',
-        manifestCandidates: ['pi.json', 'extension.json', 'plugin.json', 'package.json']
+        manifestCandidates: ['omp.json', 'extension.json', 'plugin.json', 'package.json']
       });
     })
     .filter(Boolean);
-  const control = exportPluginControlSnapshot('pi', service);
-  const piSettings = readNativeConfigSnapshot({ path: PI_SETTINGS_PATH, format: 'json' });
-  if (piSettings) {
-    control.nativeSettings = piSettings;
-  }
+  const control = exportPluginControlSnapshot('omp', service);
   return { plugins, control };
 }
 
@@ -940,8 +1148,8 @@ function exportPluginsSnapshotByPlatform() {
         result[platform] = exportCodexPluginsByPlatform(service);
       } else if (platform === 'opencode') {
         result[platform] = exportOpenCodePluginsByPlatform(service);
-      } else if (platform === 'pi') {
-        result[platform] = exportPiPluginsByPlatform(service);
+      } else if (platform === 'omp') {
+        result[platform] = exportOmpPluginsByPlatform(service);
       } else {
         result[platform] = {
           plugins: service.listPlugins().plugins || [],
@@ -1307,33 +1515,68 @@ function writeOpenCodePluginConfig(packages = [], overwrite = true) {
   return writeJsonFileAbsolute(configPath, { ...existing, plugin: mergedPlugins }, true);
 }
 
-function writePiPluginSettings(plugins = [], snapshot = {}, overwrite = true) {
+function writeOmpPluginSettings(plugins = [], snapshot = {}, overwrite = true) {
   const nativeSettings = snapshot.control?.nativeSettings;
   if (nativeSettings?.content !== undefined) {
-    return writeNativeConfigAbsolute({ path: PI_SETTINGS_PATH, format: 'json' }, nativeSettings, overwrite);
+    return writeNativeConfigAbsolute({ path: OMP_SETTINGS_PATH, format: 'yaml' }, {
+      ...nativeSettings,
+      format: 'yaml'
+    }, overwrite);
   }
 
-  const settings = readJsonFileSafe(PI_SETTINGS_PATH) || {};
-  if (fs.existsSync(PI_SETTINGS_PATH) && !overwrite) {
+  const settings = readYamlFileSafe(OMP_SETTINGS_PATH) || {};
+  if (fs.existsSync(OMP_SETTINGS_PATH) && !overwrite) {
     return 'skipped';
   }
   const existingPackages = Array.isArray(settings.packages) ? settings.packages : [];
   const existingDisabled = Array.isArray(settings.disabledPackages) ? settings.disabledPackages : [];
-  const packagePlugins = plugins.filter(plugin => plugin.type === 'pi-package' || plugin.pluginType === 'package');
-  const packages = packagePlugins.map(plugin => plugin.name).filter(Boolean);
+  const packagePlugins = plugins.filter(plugin => plugin.type === 'omp-package' || plugin.pluginType === 'package');
+  const packageIdentity = (item) => {
+    if (typeof item === 'string') return item;
+    if (!item || typeof item !== 'object') return '';
+    return item.name || item.installSource || item.source || '';
+  };
+  const buildPackageEntry = (plugin) => {
+    const name = plugin.name || plugin.directory || plugin.installSource || '';
+    if (!name) return null;
+    const installSource = plugin.installSource || plugin.packageSource || '';
+    const resourceTypes = normalizeOmpResourceTypes(plugin.resourceTypes || plugin.resources);
+    if (!installSource || installSource === name) {
+      if (resourceTypes.length === 0 && !plugin.version && !plugin.description) return name;
+    }
+    return {
+      name,
+      ...(installSource ? { source: installSource, installSource } : {}),
+      ...(plugin.version ? { version: plugin.version } : {}),
+      ...(plugin.description ? { description: plugin.description } : {}),
+      ...(resourceTypes.length > 0 ? { resourceTypes } : {})
+    };
+  };
+  const mergePackageEntries = (current, additions) => {
+    const result = [];
+    const seen = new Set();
+    for (const item of [...current, ...additions]) {
+      const identity = packageIdentity(item);
+      if (!identity || seen.has(identity)) continue;
+      seen.add(identity);
+      result.push(item);
+    }
+    return result;
+  };
+  const packages = packagePlugins.map(buildPackageEntry).filter(Boolean);
   const disabledPackages = packagePlugins
     .filter(plugin => plugin.enabled === false)
-    .map(plugin => plugin.name)
+    .map(buildPackageEntry)
     .filter(Boolean);
 
   if (packages.length === 0 && disabledPackages.length === 0) {
     return 'skipped';
   }
 
-  return writeJsonFileAbsolute(PI_SETTINGS_PATH, {
+  return writeYamlFileAbsolute(OMP_SETTINGS_PATH, {
     ...settings,
-    packages: Array.from(new Set([...existingPackages, ...packages])),
-    disabledPackages: Array.from(new Set([...existingDisabled, ...disabledPackages]))
+    packages: mergePackageEntries(existingPackages, packages),
+    disabledPackages: mergePackageEntries(existingDisabled, disabledPackages)
   }, true);
 }
 
@@ -1419,8 +1662,8 @@ function importPluginsByPlatformSnapshot(snapshotByPlatform = {}, legacyPlugins
         .map(plugin => plugin.name || plugin.directory)
         .filter(Boolean);
       applyImportStatus(results, writeOpenCodePluginConfig(packages, overwrite));
-    } else if (platform === 'pi' && (hasControl || plugins.length > 0)) {
-      applyImportStatus(results, writePiPluginSettings(plugins, snapshot, overwrite));
+    } else if (platform === 'omp' && (hasControl || plugins.length > 0)) {
+      applyImportStatus(results, writeOmpPluginSettings(plugins, snapshot, overwrite));
     }
 
     for (const plugin of plugins) {
@@ -1432,11 +1675,11 @@ function importPluginsByPlatformSnapshot(snapshotByPlatform = {}, legacyPlugins
             continue;
           }
           applyImportStatus(results, importPluginToDirectory(platform, plugin, getOpenCodePluginsDir(), overwrite));
-        } else if (platform === 'pi') {
-          if (plugin.type === 'pi-package' || plugin.pluginType === 'package') {
+        } else if (platform === 'omp') {
+          if (plugin.type === 'omp-package' || plugin.pluginType === 'package') {
             continue;
           }
-          applyImportStatus(results, importPluginToDirectory(platform, plugin, PI_EXTENSIONS_DIR, overwrite));
+          applyImportStatus(results, importPluginToDirectory(platform, plugin, OMP_EXTENSIONS_DIR, overwrite));
         } else if (platform === 'claude') {
           const isLegacy = plugin.type === 'legacy';
           applyImportStatus(results, importPluginToDirectory(
@@ -1507,7 +1750,8 @@ function getAllChannelsByType() {
   const codex = codexChannelsService.getChannels()?.channels || [];
   const gemini = geminiChannelsService.getChannels()?.channels || [];
   const opencode = opencodeChannelsService.getChannels()?.channels || [];
-  return { claude, codex, gemini, opencode };
+  const omp = ompChannelsService.getChannels()?.channels || [];
+  return { claude, codex, gemini, opencode, omp };
 }
 
 /**
@@ -1718,7 +1962,8 @@ async function importConfigs(importData, options = {}) {
         : (Array.isArray(channels) ? channels : []),
       codex: hasTypedChannels && Array.isArray(channelsByType.codex) ? channelsByType.codex : [],
       gemini: hasTypedChannels && Array.isArray(channelsByType.gemini) ? channelsByType.gemini : [],
-      opencode: hasTypedChannels && Array.isArray(channelsByType.opencode) ? channelsByType.opencode : []
+      opencode: hasTypedChannels && Array.isArray(channelsByType.opencode) ? channelsByType.opencode : [],
+      omp: hasTypedChannels && Array.isArray(channelsByType.omp) ? channelsByType.omp: []
     };
 
     // 导入配置模板
@@ -1815,6 +2060,18 @@ async function importConfigs(importData, options = {}) {
       (channel.name && channel.baseUrl && c.name === channel.name && c.baseUrl === channel.baseUrl)
     ));
 
+    importTypedChannels('omp', ompChannelsService, channel => {
+      const { name, baseUrl, apiKey, ...extraConfig } = channel;
+      ompChannelsService.createChannel(name, baseUrl, apiKey, extraConfig);
+    }, (existingChannels, channel) => existingChannels.find(c =>
+      (channel.id && c.id === channel.id) ||
+      (channel.providerKey && c.providerKey === channel.providerKey) ||
+      (channel.name && channel.baseUrl && c.name === channel.name && c.baseUrl === channel.baseUrl)
+    ));
+    if ((importChannelsByType.omp || []).length > 0 && typeof ompChannelsService.syncManagedProviderExtension === 'function') {
+      ompChannelsService.syncManagedProviderExtension();
+    }
+
     // 导入工作区配置
     if (workspaces && overwrite) {
       try {

package/src/server/services/config-registry-service.js

@@ -17,33 +17,32 @@ const REGISTRY_FILE = PATHS.configRegistry;
 const CONFIGS_DIR = PATHS.configs;
 
 // Claude Code native directories
-const CLAUDE_HOME_DIR = path.dirname(NATIVE_PATHS.claude.settings);
+const CLAUDE_HOME_DIR = NATIVE_PATHS.claude.dir || path.dirname(NATIVE_PATHS.claude.settings);
 const CLAUDE_DIRS = {
-  skills: path.join(CLAUDE_HOME_DIR, 'skills'),
-  commands: path.join(CLAUDE_HOME_DIR, 'commands'),
-  agents: path.join(CLAUDE_HOME_DIR, 'agents'),
-  plugins: path.join(CLAUDE_HOME_DIR, 'plugins')
+  skills: NATIVE_PATHS.claude.skills || path.join(CLAUDE_HOME_DIR, 'skills'),
+  commands: NATIVE_PATHS.claude.commands || path.join(CLAUDE_HOME_DIR, 'commands'),
+  agents: NATIVE_PATHS.claude.agents || path.join(CLAUDE_HOME_DIR, 'agents'),
+  plugins: NATIVE_PATHS.claude.plugins || path.join(CLAUDE_HOME_DIR, 'plugins')
 };
 
 // Valid config types
 const CONFIG_TYPES = ['skills', 'commands', 'agents', 'plugins'];
-const SUPPORTED_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode'];
+const SUPPORTED_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode', 'omp'];
 
 const PLATFORM_SUPPORT = {
-  skills: { claude: true, codex: true, gemini: true, opencode: true },
-  commands: { claude: true, codex: true, gemini: true, opencode: true },
-  agents: { claude: true, codex: true, gemini: true, opencode: true },
-  plugins: { claude: true, codex: false, gemini: false, opencode: true }
+  skills: { claude: true, codex: true, gemini: true, opencode: true, omp: true },
+  commands: { claude: true, codex: true, gemini: true, opencode: true, omp: true },
+  agents: { claude: true, codex: true, gemini: true, opencode: true, omp: false },
+  plugins: { claude: true, codex: false, gemini: false, opencode: true, omp: true }
 };
 
 function normalizePlatforms(type, platforms = {}) {
   const support = PLATFORM_SUPPORT[type] || {};
-  const normalized = {
-    claude: !!platforms.claude,
-    codex: !!platforms.codex,
-    gemini: !!platforms.gemini,
-    opencode: !!platforms.opencode
-  };
+  const normalized = {};
+
+  for (const platform of SUPPORTED_PLATFORMS) {
+    normalized[platform] = !!platforms?.[platform];
+  }
 
   for (const platform of SUPPORTED_PLATFORMS) {
     if (support[platform] === false) {
@@ -585,7 +584,8 @@ class ConfigRegistryService {
         claude: 0,
         codex: 0,
         gemini: 0,
-        opencode: 0
+        opencode: 0,
+        omp: 0
       }
     };
 
@@ -598,7 +598,8 @@ class ConfigRegistryService {
         claude: items.filter(i => i.platforms?.claude).length,
         codex: items.filter(i => i.platforms?.codex).length,
         gemini: items.filter(i => i.platforms?.gemini).length,
-        opencode: items.filter(i => i.platforms?.opencode).length
+        opencode: items.filter(i => i.platforms?.opencode).length,
+        omp: items.filter(i => i.platforms?.omp).length
       };
 
       stats.byType[type] = typeStats;
@@ -607,6 +608,7 @@ class ConfigRegistryService {
       stats.byPlatform.codex += typeStats.codex;
       stats.byPlatform.gemini += typeStats.gemini;
       stats.byPlatform.opencode += typeStats.opencode;
+      stats.byPlatform.omp += typeStats.omp;
     }
 
     return stats;