coding-tool-x 3.8.4 → 3.8.5

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

@@ -10,16 +10,93 @@ 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 { AgentsService } = require('../../platforms/agents-service');
+const { CommandsService } = require('../../platforms/commands-service');
 const { SkillService } = require('./skill-service');
 const { PluginsService } = require('./plugins-service');
 const { PATHS, NATIVE_PATHS } = require('../../config/paths');
+const { getPlatformCatalog } = require('./platform-catalog');
+const { getPlatformContext } = require('../platform-context');
+
+function getChannelDriver(platform) {
+  return getPlatformCatalog().driver(platform, 'channels');
+}
+
+function getExportRegistry() {
+  try {
+    return getPlatformContext().registry;
+  } catch {
+    return null;
+  }
+}
+
+function getPlatformPathContext(platform, registry = getExportRegistry()) {
+  try {
+    return registry?.resolvePathContext?.(platform) || null;
+  } catch {
+    return null;
+  }
+}
+
+function getConfiguredNativePaths(platform, registry = getExportRegistry()) {
+  const pathContext = getPlatformPathContext(platform, registry);
+  return pathContext?.customized ? (pathContext.native || {}) : (NATIVE_PATHS[platform] || {});
+}
+
+function getConfiguredStatePath(category, platform, registry = getExportRegistry()) {
+  const pathContext = getPlatformPathContext(platform, registry);
+  if (pathContext?.customized && pathContext.state?.[category]) {
+    return pathContext.state[category];
+  }
+  try {
+    const pathsModule = require('../../config/paths');
+    if (typeof pathsModule.getPlatformStatePath === 'function') {
+      return pathsModule.getPlatformStatePath(category, platform);
+    }
+  } catch {
+    // Fall back to the built-in maps for isolated tests.
+  }
+  return PATHS[category]?.[platform];
+}
+
+function getPlatformPluginPaths(platform, registry = getExportRegistry()) {
+  const native = getConfiguredNativePaths(platform, registry);
+  if (platform === 'claude') {
+    const pluginsDir = native.plugins
+      || path.join(native.dir || path.dirname(native.settings || CLAUDE_SETTINGS_PATH), 'plugins');
+    return {
+      pluginsDir,
+      installedRegistry: path.join(pluginsDir, 'installed_plugins.json'),
+      marketplacesRegistry: path.join(pluginsDir, 'known_marketplaces.json'),
+      cacheDir: path.join(pluginsDir, 'cache')
+    };
+  }
+  if (platform === 'codex') {
+    const pluginsDir = path.join(native.dir || path.dirname(native.config || NATIVE_PATHS.codex.config), 'plugins');
+    return {
+      pluginsDir,
+      cacheDir: path.join(pluginsDir, 'cache'),
+      configPath: native.config || NATIVE_PATHS.codex.config
+    };
+  }
+  if (platform === 'opencode') {
+    const pluginsDir = path.join(native.config || NATIVE_PATHS.opencode.config, 'plugins');
+    return {
+      pluginsDir,
+      legacyPluginsDir: path.join(native.config || NATIVE_PATHS.opencode.config, 'plugin'),
+      configDir: native.config || NATIVE_PATHS.opencode.config
+    };
+  }
+  if (platform === 'omp') {
+    const root = native.dir || NATIVE_PATHS.omp.dir;
+    return {
+      extensionsDir: native.extensions || path.join(root, 'extensions'),
+      settingsPath: native.settings || native.config || path.join(root, 'config.yml')
+    };
+  }
+  return {};
+}
+
 
 const CONFIG_VERSION = '1.4.0';
 const SKILL_FILE_ENCODING = 'base64';
@@ -52,12 +129,50 @@ const CC_UI_CONFIG_PATH = PATHS.uiConfig;
 const CC_PROMPTS_PATH = PATHS.prompts;
 const CC_SECURITY_PATH = PATHS.security;
 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', 'codex', 'gemini', 'opencode', 'omp'];
-const SKILL_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode', 'omp'];
-const PLUGIN_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode', 'omp'];
+const LEGACY_NOTIFY_HOOK_PATH = PATHS.notifyHook;
+function getPlatformKeysForType(type, registry) {
+  if (registry && typeof registry.list === 'function') {
+    return registry.list({ enabledOnly: true })
+      .filter(platform => platform && platform.key && platform.capabilities?.resourceSync !== 'unsupported')
+      .filter(platform => platform.resourceTypes?.[type] !== false)
+      .map(platform => platform.key);
+  }
+  return getPlatformCatalog().keys({ resourceType: type });
+}
+
+function getAgentPlatforms(registry = getExportRegistry()) {
+  return getPlatformKeysForType('agents', registry);
+}
+
+function getCommandPlatforms(registry = getExportRegistry()) {
+  return getPlatformKeysForType('commands', registry);
+}
+
+function getSkillPlatforms(registry = getExportRegistry()) {
+  return getPlatformKeysForType('skills', registry);
+}
+
+function getPluginPlatforms(registry = getExportRegistry()) {
+  if (registry && typeof registry.list === 'function') {
+    return registry.list({ enabledOnly: true })
+      .filter(platform => platform && platform.key && platform.capabilities?.resourceSync !== 'unsupported')
+      .map(platform => platform.key);
+  }
+  return getPlatformCatalog().keys({ capability: 'resourceSync' });
+}
+
+function exportPlatformSnapshots({ registry, exportByPlatform } = {}) {
+  if (typeof exportByPlatform !== 'function') return {};
+  const platforms = registry && typeof registry.list === 'function'
+    ? registry.list({ enabledOnly: true })
+    : getPlatformCatalog().list({ enabledOnly: true });
+  return Object.fromEntries(
+    platforms
+      .filter(platform => platform && platform.key)
+      .map(platform => [platform.key, exportByPlatform(platform.key)])
+  );
+}
 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');
@@ -111,7 +226,7 @@ function normalizeOmpResourceTypes(input = []) {
 
 function getOpenCodeConfigPaths() {
   try {
-    const { CONFIG_PATHS } = require('./opencode-settings-manager');
+    const { CONFIG_PATHS } = require('../../platforms/drivers/opencode/native-config-implementation');
     return CONFIG_PATHS || {};
   } catch (err) {
     return {};
@@ -120,52 +235,13 @@ function getOpenCodeConfigPaths() {
 
 function getOpenCodeNotificationPluginPath() {
   try {
-    const { getOpenCodeManagedPluginPath } = require('./notification-hooks');
+    const { getOpenCodeManagedPluginPath } = require('../../platforms/notification-hooks');
     return typeof getOpenCodeManagedPluginPath === 'function' ? getOpenCodeManagedPluginPath() : '';
   } catch (err) {
     return '';
   }
 }
 
-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' }
-    },
-    codex: {
-      config: { path: NATIVE_PATHS.codex.config, format: 'text' },
-      auth: { path: NATIVE_PATHS.codex.auth, format: 'json', mode: 0o600 }
-    },
-    gemini: {
-      env: { path: NATIVE_PATHS.gemini.env, format: 'text', mode: 0o600 },
-      settings: { path: GEMINI_SETTINGS_PATH, format: 'json' }
-    },
-    opencode: {
-      opencodeJsonc: { path: openCodeConfigPaths.opencodec, format: 'text' },
-      opencodeJson: { path: openCodeConfigPaths.opencode, format: 'text' },
-      configJson: { path: openCodeConfigPaths.config, format: 'text' },
-      ...(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' }
-    }
-  };
-}
 
 function ensureDir(dirPath) {
   if (!fs.existsSync(dirPath)) {
@@ -531,29 +607,41 @@ function buildCommandExportItem(command, platform) {
   };
 }
 
-function exportAgentsSnapshotByPlatform() {
-  return AGENT_PLATFORMS.reduce((result, platform) => {
+function exportAgentsSnapshotByPlatform(registry = getExportRegistry()) {
+  return getAgentPlatforms(registry).reduce((result, platform) => {
+    let agentsService;
     try {
-      const agentsService = new AgentsService(platform);
+      agentsService = new AgentsService(platform, { registry });
       const { agents: rawAgents = [] } = agentsService.listAgents();
-      result[platform] = rawAgents.map(agent => buildAgentExportItem(agent, platform));
+      result[platform] = rawAgents.map(agent => {
+        const detail = typeof agentsService.getAgent === 'function' ? (agentsService.getAgent(agent.fileName, agent.scope || 'user') || agent) : agent;
+        return buildAgentExportItem({ ...agent, ...detail }, platform);
+      });
     } catch (err) {
       console.warn(`[ConfigExport] Failed to export agents for ${platform}:`, err.message);
       result[platform] = [];
+    } finally {
+      agentsService?.dispose?.();
     }
     return result;
   }, {});
 }
 
-function exportCommandsSnapshotByPlatform() {
-  return COMMAND_PLATFORMS.reduce((result, platform) => {
+function exportCommandsSnapshotByPlatform(registry = getExportRegistry()) {
+  return getCommandPlatforms(registry).reduce((result, platform) => {
+    let commandsService;
     try {
-      const commandsService = new CommandsService(platform);
+      commandsService = new CommandsService(platform, { registry });
       const { commands: rawCommands = [] } = commandsService.listCommands();
-      result[platform] = rawCommands.map(command => buildCommandExportItem(command, platform));
+      result[platform] = rawCommands.map(command => {
+        const detail = typeof commandsService.getCommand === 'function' ? (commandsService.getCommand(command.name, command.scope || 'user', null, command.namespace) || command) : command;
+        return buildCommandExportItem({ ...command, ...detail }, platform);
+      });
     } catch (err) {
       console.warn(`[ConfigExport] Failed to export commands for ${platform}:`, err.message);
       result[platform] = [];
+    } finally {
+      commandsService?.dispose?.();
     }
     return result;
   }, {});
@@ -716,71 +804,33 @@ function buildOpenCodeNativeConfig(channels = []) {
 }
 
 function syncImportedChannelsToNativeConfigs(importChannelsByType, nativeConfigs, overwrite) {
-  const hasNativeConfigFor = (platform) => !!nativeConfigs?.[platform] && Object.keys(nativeConfigs[platform]).length > 0;
-
-  try {
-    if (!hasNativeConfigFor('claude')) {
-      const primaryClaudeChannel = pickPrimaryChannel(importChannelsByType.claude);
-      const persistedClaudeChannel = findMatchingPersistedChannel(
-        channelsService.getAllChannels?.() || [],
-        primaryClaudeChannel,
-        [
-          (channel, imported) => channel.name === imported.name && channel.baseUrl === imported.baseUrl
-        ]
-      );
-      if (persistedClaudeChannel?.id) {
-        ensureDir(path.dirname(NATIVE_PATHS.claude.settings));
-        channelsService.applyChannelToSettings(persistedClaudeChannel.id);
-      }
+  const catalog = getPlatformCatalog();
+  for (const platform of catalog.keys({ capability: 'channels' })) {
+    const channels = importChannelsByType?.[platform] || [];
+    if (channels.length === 0 || (nativeConfigs?.[platform] && Object.keys(nativeConfigs[platform]).length > 0)) {
+      continue;
     }
-  } catch (err) {
-    console.warn('[ConfigImport] Claude native sync fallback failed:', err.message);
-  }
 
-  try {
-    if (!hasNativeConfigFor('codex') && (importChannelsByType.codex || []).length > 0) {
-      codexChannelsService.writeCodexConfigForMultiChannel(importChannelsByType.codex || []);
-    }
-  } catch (err) {
-    console.warn('[ConfigImport] Codex native sync fallback failed:', err.message);
-  }
+    try {
+      const nativeDriver = catalog.driver(platform, 'nativeConfig');
+      if (typeof nativeDriver?.syncChannels === 'function') {
+        nativeDriver.syncChannels(channels, { overwrite });
+        continue;
+      }
 
-  try {
-    if (!hasNativeConfigFor('gemini')) {
-      const primaryGeminiChannel = pickPrimaryChannel(importChannelsByType.gemini);
-      const persistedGeminiChannel = findMatchingPersistedChannel(
-        geminiChannelsService.getChannels?.().channels || [],
-        primaryGeminiChannel,
-        [
-          (channel, imported) => channel.name === imported.name && channel.baseUrl === imported.baseUrl
-        ]
-      );
-      if (persistedGeminiChannel?.id) {
-        geminiChannelsService.applyChannelToSettings(persistedGeminiChannel.id);
+      const channelDriver = catalog.driver(platform, 'channels');
+      if (typeof channelDriver?.writeMultiChannelConfig === 'function') {
+        channelDriver.writeMultiChannelConfig(channels);
+        continue;
       }
-    }
-  } catch (err) {
-    console.warn('[ConfigImport] Gemini native sync fallback failed:', err.message);
-  }
 
-  try {
-    if (!hasNativeConfigFor('opencode') && (importChannelsByType.opencode || []).length > 0) {
-      const openCodeSpecs = getNativeConfigSpecs().opencode || {};
-      const preferredSpec = [
-        openCodeSpecs.opencodeJsonc,
-        openCodeSpecs.opencodeJson,
-        openCodeSpecs.configJson
-      ].find(spec => spec?.path && fs.existsSync(spec.path))
-        || openCodeSpecs.opencodeJson
-        || openCodeSpecs.configJson;
-
-      if (preferredSpec?.path) {
-        const payload = buildOpenCodeNativeConfig(importChannelsByType.opencode || []);
-        writeTextFileAbsolute(preferredSpec.path, JSON.stringify(payload, null, 2), overwrite);
+      if (typeof channelDriver?.applyChannelToSettings === 'function') {
+        const primary = pickPrimaryChannel(channels);
+        if (primary?.id) channelDriver.applyChannelToSettings(primary.id);
       }
+    } catch (err) {
+      console.warn(`[ConfigImport] ${platform} native sync fallback failed:`, err.message);
     }
-  } catch (err) {
-    console.warn('[ConfigImport] OpenCode native sync fallback failed:', err.message);
   }
 }
 
@@ -968,8 +1018,8 @@ function readJsonConfigSnapshot(filePath) {
 
 function exportPluginControlSnapshot(platform, service) {
   const snapshot = {};
-  const reposPath = PATHS.pluginRepos?.[platform];
-  const marketCachePath = PATHS.pluginMarketCache?.[platform];
+  const reposPath = service?.getReposConfigPath?.() || getConfiguredStatePath('pluginRepos', platform, service?.registry);
+  const marketCachePath = service?.marketCachePath || getConfiguredStatePath('pluginMarketCache', platform, service?.registry);
   const repos = readJsonConfigSnapshot(reposPath);
   const marketCache = readJsonConfigSnapshot(marketCachePath);
 
@@ -993,12 +1043,15 @@ function exportPluginControlSnapshot(platform, service) {
 }
 
 function exportClaudePluginsByPlatform(service) {
+  const pluginsDir = service.claudePluginsDir || CLAUDE_PLUGINS_DIR;
+  const installedRegistryPath = service.claudeInstalledFile || NATIVE_PLUGINS_REGISTRY;
+  const marketplacesRegistryPath = service.claudeMarketplacesFile || CLAUDE_MARKETPLACES_REGISTRY;
   const installedPlugins = service.listPlugins().plugins || [];
   const plugins = [];
 
   for (const plugin of installedPlugins) {
     if (plugin.installPath && fs.existsSync(plugin.installPath)) {
-      const pluginDir = assertPathInside(CLAUDE_PLUGINS_DIR, plugin.installPath)
+      const pluginDir = assertPathInside(pluginsDir, plugin.installPath)
         || assertPathInside(LEGACY_PLUGINS_DIR, plugin.installPath);
       if (pluginDir) {
         const { manifest, manifestPath } = detectPluginManifest(pluginDir, [
@@ -1018,7 +1071,7 @@ function exportClaudePluginsByPlatform(service) {
             version: manifest.version || plugin.version || '1.0.0',
             description: manifest.description || plugin.description || '',
             author: manifest.author || plugin.author || '',
-            directory: path.relative(CLAUDE_PLUGINS_DIR, pluginDir),
+            directory: path.relative(pluginsDir, pluginDir),
             enabled: plugin.enabled !== false,
             installedAt: plugin.installedAt,
             scope: plugin.scope,
@@ -1050,8 +1103,8 @@ function exportClaudePluginsByPlatform(service) {
   }
 
   const control = exportPluginControlSnapshot('claude', service);
-  const installedRegistry = readJsonConfigSnapshot(NATIVE_PLUGINS_REGISTRY);
-  const knownMarketplaces = readJsonConfigSnapshot(CLAUDE_MARKETPLACES_REGISTRY);
+  const installedRegistry = readJsonConfigSnapshot(installedRegistryPath);
+  const knownMarketplaces = readJsonConfigSnapshot(marketplacesRegistryPath);
   const legacyRegistry = readJsonConfigSnapshot(LEGACY_PLUGINS_REGISTRY);
   if (installedRegistry) control.installedRegistry = installedRegistry;
   if (knownMarketplaces) control.knownMarketplaces = knownMarketplaces;
@@ -1062,14 +1115,16 @@ function exportClaudePluginsByPlatform(service) {
 
 function exportCodexPluginsByPlatform(service) {
   const plugins = (service.listPlugins().plugins || [])
-    .map(plugin => buildManagedPluginExportItem(plugin, 'codex', CODEX_PLUGINS_CACHE_DIR, {
+    .map(plugin => buildManagedPluginExportItem(plugin, 'codex', service.codexPluginsCacheDir || CODEX_PLUGINS_CACHE_DIR, {
       type: 'codex-cache',
       pluginType: 'cache',
       manifestCandidates: ['.codex-plugin/plugin.json', 'plugin.json', 'package.json']
     }))
     .filter(Boolean);
   const control = exportPluginControlSnapshot('codex', service);
-  const codexConfig = readNativeConfigSnapshot({ path: NATIVE_PATHS.codex.config, format: 'text' });
+  const codexConfig = readNativeConfigSnapshot({ path: service.pathContext?.customized
+    ? service.pathContext.native?.config
+    : NATIVE_PATHS.codex.config, format: 'text' });
   if (codexConfig) {
     control.nativeConfig = codexConfig;
   }
@@ -1077,7 +1132,7 @@ function exportCodexPluginsByPlatform(service) {
 }
 
 function exportOpenCodePluginsByPlatform(service) {
-  const pluginsDir = getOpenCodePluginsDir();
+  const pluginsDir = service._getOpenCodePluginsDir?.() || getOpenCodePluginsDir();
   const plugins = (service.listPlugins().plugins || [])
     .map((plugin) => {
       if (plugin.pluginType === 'npm' || plugin.source === 'opencode-config') {
@@ -1109,6 +1164,9 @@ function exportOpenCodePluginsByPlatform(service) {
 }
 
 function exportOmpPluginsByPlatform(service) {
+  const extensionsDir = service.pathContext?.customized
+    ? (service.pathContext.native?.extensions || path.join(service.pathContext.native?.dir || '', 'extensions'))
+    : OMP_EXTENSIONS_DIR;
   const plugins = (service.listPlugins().plugins || [])
     .map((plugin) => {
       if (plugin.pluginType === 'package' || plugin.source === 'omp-settings') {
@@ -1126,7 +1184,7 @@ function exportOmpPluginsByPlatform(service) {
           source: plugin.source || 'omp-settings'
         };
       }
-      return buildManagedPluginExportItem(plugin, 'omp', OMP_EXTENSIONS_DIR, {
+      return buildManagedPluginExportItem(plugin, 'omp', extensionsDir, {
         type: 'omp-extension',
         pluginType: plugin.pluginType || 'extension',
         pluginKind: plugin.pluginKind || 'extension',
@@ -1138,10 +1196,10 @@ function exportOmpPluginsByPlatform(service) {
   return { plugins, control };
 }
 
-function exportPluginsSnapshotByPlatform() {
-  return PLUGIN_PLATFORMS.reduce((result, platform) => {
+function exportPluginsSnapshotByPlatform(registry = getExportRegistry()) {
+  return getPluginPlatforms(registry).reduce((result, platform) => {
     try {
-      const service = new PluginsService(platform);
+      const service = new PluginsService(platform, { registry });
       if (platform === 'claude') {
         result[platform] = exportClaudePluginsByPlatform(service);
       } else if (platform === 'codex') {
@@ -1164,8 +1222,8 @@ function exportPluginsSnapshotByPlatform() {
   }, {});
 }
 
-function exportSkillsSnapshot(platform = 'claude') {
-  const skillService = new SkillService(platform);
+function exportSkillsSnapshot(platform = 'claude', registry = getExportRegistry()) {
+  const skillService = new SkillService(platform, { registry });
   const installedSkills = skillService.getInstalledSkills();
   const baseDir = skillService.installDir;
 
@@ -1185,10 +1243,10 @@ function exportSkillsSnapshot(platform = 'claude') {
   }).filter(Boolean);
 }
 
-function exportSkillsSnapshotByPlatform() {
-  return SKILL_PLATFORMS.reduce((result, platform) => {
+function exportSkillsSnapshotByPlatform(registry = getExportRegistry()) {
+  return getSkillPlatforms(registry).reduce((result, platform) => {
     try {
-      result[platform] = exportSkillsSnapshot(platform);
+      result[platform] = exportSkillsSnapshot(platform, registry);
     } catch (err) {
       console.warn(`[ConfigExport] Failed to export skills for ${platform}:`, err.message);
       result[platform] = [];
@@ -1197,22 +1255,20 @@ function exportSkillsSnapshotByPlatform() {
   }, {});
 }
 
-function exportNativeConfigs() {
-  const specs = getNativeConfigSpecs();
-  return Object.entries(specs).reduce((result, [platform, platformSpecs]) => {
-    const exportedEntries = Object.entries(platformSpecs).reduce((entries, [key, spec]) => {
-      const snapshot = readNativeConfigSnapshot(spec);
-      if (snapshot) {
-        entries[key] = snapshot;
-      }
-      return entries;
-    }, {});
-
-    if (Object.keys(exportedEntries).length > 0) {
-      result[platform] = exportedEntries;
-    }
-    return result;
-  }, {});
+function exportNativeConfigs(registry = getExportRegistry()) {
+  const result = {};
+  const platforms = registry && typeof registry.list === 'function'
+    ? registry.list({ enabledOnly: true })
+      .filter(platform => platform?.key && platform.capabilities?.nativeConfig !== 'unsupported')
+      .map(platform => platform.key)
+    : getPlatformCatalog().keys({ capability: 'nativeConfig' });
+  for (const platform of platforms) {
+    const driver = getPlatformCatalog().driver(platform, 'nativeConfig');
+    if (!driver || typeof driver.exportSnapshot !== 'function') continue;
+    const snapshot = driver.exportSnapshot();
+    if (snapshot && Object.keys(snapshot).length > 0) result[platform] = snapshot;
+  }
+  return result;
 }
 
 function exportLegacyPlugins() {
@@ -1322,14 +1378,15 @@ function exportPluginsSnapshot() {
   return [...legacyPlugins, ...nativePlugins];
 }
 
-function getPluginsByPlatformItems(plugins = [], pluginsByPlatform = {}) {
-  const result = Object.fromEntries(PLUGIN_PLATFORMS.map(platform => [platform, []]));
+function getPluginsByPlatformItems(plugins = [], pluginsByPlatform = {}, registry = getExportRegistry()) {
+  const supportedPlatforms = getPluginPlatforms(registry);
+  const result = Object.fromEntries(supportedPlatforms.map(platform => [platform, []]));
   const hasStructuredPlugins = pluginsByPlatform
     && typeof pluginsByPlatform === 'object'
     && Object.keys(pluginsByPlatform).length > 0;
 
   if (hasStructuredPlugins) {
-    for (const platform of PLUGIN_PLATFORMS) {
+    for (const platform of supportedPlatforms) {
       const platformSnapshot = pluginsByPlatform[platform];
       const platformPlugins = Array.isArray(platformSnapshot?.plugins)
         ? platformSnapshot.plugins
@@ -1343,7 +1400,10 @@ function getPluginsByPlatformItems(plugins = [], pluginsByPlatform = {}) {
 
   if (!hasStructuredPlugins && Array.isArray(plugins)) {
     for (const plugin of plugins) {
-      const platform = PLUGIN_PLATFORMS.includes(plugin?.platform) ? plugin.platform : 'claude';
+      const platform = supportedPlatforms.includes(plugin?.platform)
+        ? plugin.platform
+        : (supportedPlatforms.includes('claude') ? 'claude' : null);
+      if (!platform) continue;
       result[platform].push({ ...plugin, platform });
     }
   }
@@ -1439,9 +1499,9 @@ function mergeTomlFile(filePath, updates = {}, overwrite = true) {
   return 'success';
 }
 
-function mergePluginRepoConfig(platform, snapshot = {}, overwrite = true) {
-  const reposPath = PATHS.pluginRepos?.[platform];
-  const marketCachePath = PATHS.pluginMarketCache?.[platform];
+function mergePluginRepoConfig(platform, snapshot = {}, overwrite = true, registry = getExportRegistry()) {
+  const reposPath = getConfiguredStatePath('pluginRepos', platform, registry);
+  const marketCachePath = getConfiguredStatePath('pluginMarketCache', platform, registry);
   let changed = 0;
   let skipped = 0;
   let failed = 0;
@@ -1465,10 +1525,10 @@ function mergePluginRepoConfig(platform, snapshot = {}, overwrite = true) {
   return { changed, skipped, failed };
 }
 
-function mergeCodexPluginConfig(snapshot = {}, plugins = [], overwrite = true) {
+function mergeCodexPluginConfig(snapshot = {}, plugins = [], overwrite = true, configPath = NATIVE_PATHS.codex.config) {
   const nativeConfig = snapshot.control?.nativeConfig;
   if (nativeConfig?.content !== undefined) {
-    return writeNativeConfigAbsolute({ path: NATIVE_PATHS.codex.config, format: 'text' }, nativeConfig, overwrite);
+    return writeNativeConfigAbsolute({ path: configPath, format: 'text' }, nativeConfig, overwrite);
   }
 
   const pluginEntries = {};
@@ -1490,13 +1550,13 @@ function mergeCodexPluginConfig(snapshot = {}, plugins = [], overwrite = true) {
     return 'skipped';
   }
 
-  return mergeTomlFile(NATIVE_PATHS.codex.config, {
+  return mergeTomlFile(configPath, {
     ...(Object.keys(pluginEntries).length > 0 ? { plugins: pluginEntries } : {}),
     ...(Object.keys(marketplaces).length > 0 ? { marketplaces } : {})
   }, overwrite);
 }
 
-function writeOpenCodePluginConfig(packages = [], overwrite = true) {
+function writeOpenCodePluginConfig(packages = [], overwrite = true, configDir = NATIVE_PATHS.opencode.config) {
   if (packages.length === 0) return 'skipped';
   const openCodePaths = getOpenCodeConfigPaths();
   const configPath = [
@@ -1505,7 +1565,7 @@ function writeOpenCodePluginConfig(packages = [], overwrite = true) {
     openCodePaths.config
   ].find(filePath => filePath && fs.existsSync(filePath))
     || openCodePaths.opencode
-    || path.join(NATIVE_PATHS.opencode.config, 'opencode.json');
+    || path.join(configDir, 'opencode.json');
   const existing = readJsonFileSafe(configPath) || {};
   if (fs.existsSync(configPath) && !overwrite) {
     return 'skipped';
@@ -1515,17 +1575,17 @@ function writeOpenCodePluginConfig(packages = [], overwrite = true) {
   return writeJsonFileAbsolute(configPath, { ...existing, plugin: mergedPlugins }, true);
 }
 
-function writeOmpPluginSettings(plugins = [], snapshot = {}, overwrite = true) {
+function writeOmpPluginSettings(plugins = [], snapshot = {}, overwrite = true, settingsPath = OMP_SETTINGS_PATH) {
   const nativeSettings = snapshot.control?.nativeSettings;
   if (nativeSettings?.content !== undefined) {
-    return writeNativeConfigAbsolute({ path: OMP_SETTINGS_PATH, format: 'yaml' }, {
+    return writeNativeConfigAbsolute({ path: settingsPath, format: 'yaml' }, {
       ...nativeSettings,
       format: 'yaml'
     }, overwrite);
   }
 
-  const settings = readYamlFileSafe(OMP_SETTINGS_PATH) || {};
-  if (fs.existsSync(OMP_SETTINGS_PATH) && !overwrite) {
+  const settings = readYamlFileSafe(settingsPath) || {};
+  if (fs.existsSync(settingsPath) && !overwrite) {
     return 'skipped';
   }
   const existingPackages = Array.isArray(settings.packages) ? settings.packages : [];
@@ -1573,14 +1633,14 @@ function writeOmpPluginSettings(plugins = [], snapshot = {}, overwrite = true) {
     return 'skipped';
   }
 
-  return writeYamlFileAbsolute(OMP_SETTINGS_PATH, {
+  return writeYamlFileAbsolute(settingsPath, {
     ...settings,
     packages: mergePackageEntries(existingPackages, packages),
     disabledPackages: mergePackageEntries(existingDisabled, disabledPackages)
   }, true);
 }
 
-function importPluginToDirectory(platform, plugin, baseDir, overwrite) {
+function importPluginToDirectory(platform, plugin, baseDir, overwrite, options = {}) {
   const files = Array.isArray(plugin.files) ? plugin.files : [];
   if (files.length === 0) {
     return 'skipped';
@@ -1623,7 +1683,7 @@ function importPluginToDirectory(platform, plugin, baseDir, overwrite) {
   }
 
   if (platform === 'claude') {
-    updateClaudePluginRegistry(plugin, pluginDir);
+    updateClaudePluginRegistry(plugin, pluginDir, options);
   }
 
   return 'success';
@@ -1639,14 +1699,15 @@ function applyImportStatus(results, status) {
   }
 }
 
-function importPluginsByPlatformSnapshot(snapshotByPlatform = {}, legacyPlugins = [], overwrite = true, results) {
-  const pluginsByPlatform = getPluginsByPlatformItems(legacyPlugins, snapshotByPlatform);
+function importPluginsByPlatformSnapshot(snapshotByPlatform = {}, legacyPlugins = [], overwrite = true, results, registry = getExportRegistry()) {
+  const pluginsByPlatform = getPluginsByPlatformItems(legacyPlugins, snapshotByPlatform, registry);
 
-  for (const platform of PLUGIN_PLATFORMS) {
+  for (const platform of getPluginPlatforms(registry)) {
+    const pluginPaths = getPlatformPluginPaths(platform, registry);
     const snapshot = snapshotByPlatform?.[platform] && typeof snapshotByPlatform[platform] === 'object'
       ? snapshotByPlatform[platform]
       : {};
-    const repoStatus = mergePluginRepoConfig(platform, snapshot, overwrite);
+    const repoStatus = mergePluginRepoConfig(platform, snapshot, overwrite, registry);
     results.plugins.success += repoStatus.changed;
     results.plugins.skipped += repoStatus.skipped;
     results.plugins.failed += repoStatus.failed;
@@ -1655,38 +1716,45 @@ function importPluginsByPlatformSnapshot(snapshotByPlatform = {}, legacyPlugins
     const hasControl = snapshot?.control && Object.keys(snapshot.control).length > 0;
 
     if (platform === 'codex' && (hasControl || plugins.length > 0)) {
-      applyImportStatus(results, mergeCodexPluginConfig(snapshot, plugins, overwrite));
+      applyImportStatus(results, mergeCodexPluginConfig(snapshot, plugins, overwrite, pluginPaths.configPath));
     } else if (platform === 'opencode' && (hasControl || plugins.length > 0)) {
       const packages = plugins
         .filter(plugin => plugin.type === 'opencode-package' || plugin.pluginType === 'npm')
         .map(plugin => plugin.name || plugin.directory)
         .filter(Boolean);
-      applyImportStatus(results, writeOpenCodePluginConfig(packages, overwrite));
+      applyImportStatus(results, writeOpenCodePluginConfig(packages, overwrite, pluginPaths.configDir));
     } else if (platform === 'omp' && (hasControl || plugins.length > 0)) {
-      applyImportStatus(results, writeOmpPluginSettings(plugins, snapshot, overwrite));
+      applyImportStatus(results, writeOmpPluginSettings(plugins, snapshot, overwrite, pluginPaths.settingsPath));
     }
 
     for (const plugin of plugins) {
       try {
         if (platform === 'codex') {
-          applyImportStatus(results, importPluginToDirectory(platform, plugin, CODEX_PLUGINS_CACHE_DIR, overwrite));
+          applyImportStatus(results, importPluginToDirectory(platform, plugin, pluginPaths.cacheDir || CODEX_PLUGINS_CACHE_DIR, overwrite));
         } else if (platform === 'opencode') {
           if (plugin.type === 'opencode-package' || plugin.pluginType === 'npm') {
             continue;
           }
-          applyImportStatus(results, importPluginToDirectory(platform, plugin, getOpenCodePluginsDir(), overwrite));
+          const openCodePluginsDir = fs.existsSync(pluginPaths.legacyPluginsDir) && !fs.existsSync(pluginPaths.pluginsDir)
+            ? pluginPaths.legacyPluginsDir
+            : pluginPaths.pluginsDir;
+          applyImportStatus(results, importPluginToDirectory(platform, plugin, openCodePluginsDir || getOpenCodePluginsDir(), overwrite));
         } else if (platform === 'omp') {
           if (plugin.type === 'omp-package' || plugin.pluginType === 'package') {
             continue;
           }
-          applyImportStatus(results, importPluginToDirectory(platform, plugin, OMP_EXTENSIONS_DIR, overwrite));
+          applyImportStatus(results, importPluginToDirectory(platform, plugin, pluginPaths.extensionsDir || OMP_EXTENSIONS_DIR, overwrite));
         } else if (platform === 'claude') {
           const isLegacy = plugin.type === 'legacy';
           applyImportStatus(results, importPluginToDirectory(
             platform,
             plugin,
-            isLegacy ? LEGACY_PLUGINS_DIR : CLAUDE_PLUGINS_DIR,
-            overwrite
+            isLegacy ? LEGACY_PLUGINS_DIR : (pluginPaths.pluginsDir || CLAUDE_PLUGINS_DIR),
+            overwrite,
+            isLegacy ? {} : {
+              installedRegistryPath: pluginPaths.installedRegistry,
+              settingsPath: claudeSettingsPath
+            }
           ));
         }
       } catch (err) {
@@ -1697,11 +1765,11 @@ function importPluginsByPlatformSnapshot(snapshotByPlatform = {}, legacyPlugins
   }
 }
 
-function updateClaudePluginRegistry(plugin, pluginDir) {
+function updateClaudePluginRegistry(plugin, pluginDir, { installedRegistryPath = NATIVE_PLUGINS_REGISTRY, settingsPath = CLAUDE_SETTINGS_PATH } = {}) {
   const pluginName = plugin.name || path.basename(pluginDir);
   const marketplace = plugin.marketplace || '';
   const nativeKey = marketplace ? `${pluginName}@${marketplace}` : pluginName;
-  const installed = readJsonFileSafe(NATIVE_PLUGINS_REGISTRY) || { version: 2, plugins: {} };
+  const installed = readJsonFileSafe(installedRegistryPath) || { version: 2, plugins: {} };
   installed.version = installed.version || 2;
   installed.plugins = installed.plugins && typeof installed.plugins === 'object' ? installed.plugins : {};
   installed.plugins[nativeKey] = [{
@@ -1722,14 +1790,14 @@ function updateClaudePluginRegistry(plugin, pluginDir) {
     ...(plugin.repoLocalPath ? { repoLocalPath: plugin.repoLocalPath } : {}),
     ...(plugin.repoId ? { repoId: plugin.repoId } : {})
   }];
-  writeJsonFileAbsolute(NATIVE_PLUGINS_REGISTRY, installed, true);
+  writeJsonFileAbsolute(installedRegistryPath, installed, true);
 
-  const settings = readJsonFileSafe(CLAUDE_SETTINGS_PATH) || {};
+  const settings = readJsonFileSafe(settingsPath) || {};
   settings.enabledPlugins = settings.enabledPlugins && typeof settings.enabledPlugins === 'object'
     ? settings.enabledPlugins
     : {};
   settings.enabledPlugins[nativeKey] = plugin.enabled !== false;
-  writeJsonFileAbsolute(CLAUDE_SETTINGS_PATH, settings, true);
+  writeJsonFileAbsolute(settingsPath, settings, true);
 }
 
 function writeTextFile(baseDir, relativePath, content, overwrite) {
@@ -1745,21 +1813,23 @@ function writeTextFile(baseDir, relativePath, content, overwrite) {
   return 'success';
 }
 
-function getAllChannelsByType() {
-  const claude = channelsService.getAllChannels() || [];
-  const codex = codexChannelsService.getChannels()?.channels || [];
-  const gemini = geminiChannelsService.getChannels()?.channels || [];
-  const opencode = opencodeChannelsService.getChannels()?.channels || [];
-  const omp = ompChannelsService.getChannels()?.channels || [];
-  return { claude, codex, gemini, opencode, omp };
+function readDriverChannels(driver) {
+  const result = typeof driver?.list === 'function' ? driver.list() : null;
+  const data = result?.status === 'ok' ? result.data : result;
+  return Array.isArray(data) ? data : data?.channels || [];
 }
 
-/**
- * 导出所有配置为JSON
- * @returns {Object} 配置导出对象
- */
+function getAllChannelsByType() {
+  return Object.fromEntries(
+    getPlatformCatalog().keys({ capability: 'channels' })
+      .map(platform => [platform, readDriverChannels(getChannelDriver(platform))])
+  );
+}
 function exportAllConfigs() {
   try {
+    const registry = getExportRegistry();
+    const claudeNative = getConfiguredNativePaths('claude', registry);
+    const claudeSettingsPath = claudeNative.settings || CLAUDE_SETTINGS_PATH;
     // 获取所有配置模板(只导出自定义模板)
     const allConfigTemplates = configTemplatesService.getAllTemplates();
     const customConfigTemplates = allConfigTemplates.filter(t => !t.isBuiltin);
@@ -1777,9 +1847,9 @@ function exportAllConfigs() {
     const favorites = favoritesService.loadFavorites();
 
     // 获取 Agents / Skills / Commands 配置（多平台）
-    const agentsByPlatform = exportAgentsSnapshotByPlatform();
-    const skillsByPlatform = exportSkillsSnapshotByPlatform();
-    const commandsByPlatform = exportCommandsSnapshotByPlatform();
+    const agentsByPlatform = exportAgentsSnapshotByPlatform(registry);
+    const skillsByPlatform = exportSkillsSnapshotByPlatform(registry);
+    const commandsByPlatform = exportCommandsSnapshotByPlatform(registry);
     const agents = agentsByPlatform.claude || [];
     const skills = skillsByPlatform.claude || [];
     const commands = commandsByPlatform.claude || [];
@@ -1789,9 +1859,10 @@ function exportAllConfigs() {
     const mcpServers = mcpService.getAllServers();
 
     // 获取 Plugins 配置
-    const plugins = exportPluginsSnapshot();
-    const pluginsByPlatform = exportPluginsSnapshotByPlatform();
-    const nativeConfigs = exportNativeConfigs();
+    const pluginsByPlatform = exportPluginsSnapshotByPlatform(registry);
+    const plugins = Object.values(pluginsByPlatform)
+      .flatMap(snapshot => Array.isArray(snapshot?.plugins) ? snapshot.plugins : []);
+    const nativeConfigs = exportNativeConfigs(registry);
     const oauthCredentials = readJsonFileSafe(PATHS.oauthCredentials);
 
     // 读取 Markdown 配置文件
@@ -1819,7 +1890,7 @@ function exportAllConfigs() {
     const security = readJsonFileSafe(CC_SECURITY_PATH);
     const appConfig = loadConfig();
 
-    const claudeSettings = readJsonFileSafe(CLAUDE_SETTINGS_PATH);
+    const claudeSettings = readJsonFileSafe(claudeSettingsPath);
     const claudeHooks = {
       uiConfig: readJsonFileSafe(LEGACY_UI_CONFIG_PATH),
       notifyScript: readTextFileSafe(LEGACY_NOTIFY_HOOK_PATH),
@@ -1900,6 +1971,10 @@ function exportAllConfigsZip() {
  */
 async function importConfigs(importData, options = {}) {
   const { overwrite = true } = options; // 默认覆盖模式
+  const registry = options.registry || getExportRegistry();
+  const claudeNative = getConfiguredNativePaths('claude', registry);
+  const claudeSettingsPath = claudeNative.settings || CLAUDE_SETTINGS_PATH;
+  const claudePluginPaths = getPlatformPluginPaths('claude', registry);
   const results = {
     configTemplates: { success: 0, failed: 0, skipped: 0 },
     channels: { success: 0, failed: 0, skipped: 0 },
@@ -1951,20 +2026,18 @@ async function importConfigs(importData, options = {}) {
       claudeHooks = null
     } = importData.data;
 
-    const importAgentsByPlatform = normalizePlatformItems(agents, agentsByPlatform, AGENT_PLATFORMS);
-    const importSkillsByPlatform = normalizePlatformItems(skills, skillsByPlatform, SKILL_PLATFORMS);
-    const importCommandsByPlatform = normalizePlatformItems(commands, commandsByPlatform, COMMAND_PLATFORMS);
+    const importAgentsByPlatform = normalizePlatformItems(agents, agentsByPlatform, getAgentPlatforms(registry));
+    const importSkillsByPlatform = normalizePlatformItems(skills, skillsByPlatform, getSkillPlatforms(registry));
+    const importCommandsByPlatform = normalizePlatformItems(commands, commandsByPlatform, getCommandPlatforms(registry));
 
+    const channelPlatforms = getPlatformCatalog().keys({ capability: 'channels' });
     const hasTypedChannels = channelsByType && typeof channelsByType === 'object';
-    const importChannelsByType = {
-      claude: hasTypedChannels && Array.isArray(channelsByType.claude)
-        ? channelsByType.claude
-        : (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 : [],
-      omp: hasTypedChannels && Array.isArray(channelsByType.omp) ? channelsByType.omp: []
-    };
+    const importChannelsByType = Object.fromEntries(channelPlatforms.map(platform => [
+      platform,
+      hasTypedChannels && Array.isArray(channelsByType[platform])
+        ? channelsByType[platform]
+        : (platform === 'claude' && Array.isArray(channels) ? channels : [])
+    ]));
 
     // 导入配置模板
     for (const template of configTemplates) {
@@ -1994,16 +2067,23 @@ async function importConfigs(importData, options = {}) {
     }
 
     // 导入频道配置（兼容旧结构 channels 和新结构 channelsByType）
-    const importTypedChannels = (type, service, createChannel, findExisting = null) => {
-      const sourceChannels = importChannelsByType[type];
+    const importTypedChannels = (platform) => {
+      const driver = getChannelDriver(platform);
+      const sourceChannels = importChannelsByType[platform] || [];
+      if (!driver) {
+        results.channels.skipped += sourceChannels.length;
+        return;
+      }
       for (const channel of sourceChannels) {
         try {
-          const existingChannels = service.getChannels
-            ? (service.getChannels()?.channels || [])
-            : (service.getAllChannels?.() || []);
-          const existing = typeof findExisting === 'function'
-            ? findExisting(existingChannels, channel)
-            : existingChannels.find(c => c.id === channel.id);
+          const existingChannels = readDriverChannels(driver);
+          const existing = existingChannels.find(candidate => (
+            (channel.id && candidate.id === channel.id)
+            || (channel.providerKey && candidate.providerKey === channel.providerKey)
+            || (channel.name && channel.baseUrl
+              && candidate.name === channel.name
+              && candidate.baseUrl === channel.baseUrl)
+          ));
 
           if (existing && !overwrite) {
             results.channels.skipped++;
@@ -2011,68 +2091,28 @@ async function importConfigs(importData, options = {}) {
           }
 
           if (existing && overwrite) {
-            service.updateChannel(existing.id, { ...channel, id: existing.id });
+            driver.update(existing.id, { ...channel, id: existing.id });
           } else {
-            createChannel(channel);
+            driver.create(channel);
           }
           results.channels.success++;
         } catch (err) {
-          console.error(`[ConfigImport] 导入${type}频道失败: ${channel.name}`, err);
+          console.error(`[ConfigImport] 导入${platform}频道失败: ${channel.name}`, err);
           results.channels.failed++;
         }
       }
     };
 
-    importTypedChannels('claude', channelsService, channel => {
-      const { name, baseUrl, apiKey, websiteUrl, ...extraConfig } = channel;
-      channelsService.createChannel(name, baseUrl, apiKey, websiteUrl, extraConfig);
-    }, (existingChannels, channel) => existingChannels.find(c => c.id === channel.id));
-
-    importTypedChannels('codex', codexChannelsService, channel => {
-      const {
-        name,
-        providerKey,
-        baseUrl,
-        apiKey,
-        wireApi,
-        ...extraConfig
-      } = channel;
-      codexChannelsService.createChannel(name, providerKey, baseUrl, apiKey, wireApi, extraConfig);
-    }, (existingChannels, channel) => existingChannels.find(c =>
-      (channel.id && c.id === channel.id) ||
-      (channel.providerKey && c.providerKey === channel.providerKey)
-    ));
-
-    importTypedChannels('gemini', geminiChannelsService, channel => {
-      const { name, baseUrl, apiKey, model, ...extraConfig } = channel;
-      geminiChannelsService.createChannel(name, baseUrl, apiKey, model, extraConfig);
-    }, (existingChannels, channel) => existingChannels.find(c =>
-      (channel.id && c.id === channel.id) ||
-      (channel.name && c.name === channel.name)
-    ));
-
-    importTypedChannels('opencode', opencodeChannelsService, channel => {
-      const { name, baseUrl, apiKey, ...extraConfig } = channel;
-      opencodeChannelsService.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)
-    ));
-
-    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();
-    }
-
-    // 导入工作区配置
+    for (const platform of channelPlatforms) {
+      importTypedChannels(platform);
+    }
+    for (const platform of channelPlatforms) {
+      const driver = getChannelDriver(platform);
+      const imported = importChannelsByType[platform] || [];
+      if (imported.length > 0 && typeof driver?.syncManagedProviderExtension === 'function') {
+        driver.syncManagedProviderExtension(imported);
+      }
+    }
     if (workspaces && overwrite) {
       try {
         const workspaceService = require('./workspace-service');
@@ -2098,13 +2138,13 @@ async function importConfigs(importData, options = {}) {
     }
 
     // 导入 Agents（多平台）
-    if (AGENT_PLATFORMS.some(platform => importAgentsByPlatform[platform]?.length > 0)) {
+    if (getAgentPlatforms(registry).some(platform => importAgentsByPlatform[platform]?.length > 0)) {
       try {
-        for (const platform of AGENT_PLATFORMS) {
+        for (const platform of getAgentPlatforms(registry)) {
           const platformAgents = importAgentsByPlatform[platform] || [];
           if (platformAgents.length === 0) continue;
 
-          const agentsService = new AgentsService(platform);
+          const agentsService = new AgentsService(platform, { registry });
           const baseDir = agentsService.userAgentsDir;
 
           for (const agent of platformAgents) {
@@ -2127,13 +2167,13 @@ async function importConfigs(importData, options = {}) {
     }
 
     // 导入 Skills（多平台）
-    if (SKILL_PLATFORMS.some(platform => importSkillsByPlatform[platform]?.length > 0)) {
+    if (getSkillPlatforms(registry).some(platform => importSkillsByPlatform[platform]?.length > 0)) {
       try {
-        for (const platform of SKILL_PLATFORMS) {
+        for (const platform of getSkillPlatforms(registry)) {
           const platformSkills = importSkillsByPlatform[platform] || [];
           if (platformSkills.length === 0) continue;
 
-          const skillService = new SkillService(platform);
+          const skillService = new SkillService(platform, { registry });
           const baseDir = skillService.installDir;
           ensureDir(baseDir);
 
@@ -2190,7 +2230,7 @@ async function importConfigs(importData, options = {}) {
 
     // 导入 Plugins（优先使用多平台结构，兼容旧结构 plugins）
     if (pluginsByPlatform && typeof pluginsByPlatform === 'object' && Object.keys(pluginsByPlatform).length > 0) {
-      importPluginsByPlatformSnapshot(pluginsByPlatform, plugins, overwrite, results);
+      importPluginsByPlatformSnapshot(pluginsByPlatform, plugins, overwrite, results, registry);
     }
 
     // 导入旧版 Plugins 结构。新包已经通过 pluginsByPlatform 处理过，避免重复写入。
@@ -2221,8 +2261,8 @@ async function importConfigs(importData, options = {}) {
                 results.plugins.failed++;
                 continue;
               }
-              targetDir = path.join(CLAUDE_PLUGINS_DIR, pluginId);
-              registryPath = NATIVE_PLUGINS_REGISTRY;
+              targetDir = path.join(claudePluginPaths.pluginsDir || CLAUDE_PLUGINS_DIR, pluginId);
+              registryPath = claudePluginPaths.installedRegistry || NATIVE_PLUGINS_REGISTRY;
             } else {
               console.warn(`[ConfigImport] Unknown plugin type: ${pluginType}`);
               results.plugins.failed++;
@@ -2335,13 +2375,13 @@ async function importConfigs(importData, options = {}) {
     }
 
     // 导入 Commands（多平台）
-    if (COMMAND_PLATFORMS.some(platform => importCommandsByPlatform[platform]?.length > 0)) {
+    if (getCommandPlatforms(registry).some(platform => importCommandsByPlatform[platform]?.length > 0)) {
       try {
-        for (const platform of COMMAND_PLATFORMS) {
+        for (const platform of getCommandPlatforms(registry)) {
           const platformCommands = importCommandsByPlatform[platform] || [];
           if (platformCommands.length === 0) continue;
 
-          const commandsService = new CommandsService(platform);
+          const commandsService = new CommandsService(platform, { registry });
           const baseDir = commandsService.userCommandsDir;
 
           for (const command of platformCommands) {
@@ -2482,34 +2522,23 @@ async function importConfigs(importData, options = {}) {
 
     // 导入各平台原生配置
     if (nativeConfigs && typeof nativeConfigs === 'object' && Object.keys(nativeConfigs).length > 0) {
-      const nativeConfigSpecs = getNativeConfigSpecs();
-
+      const catalog = getPlatformCatalog();
       for (const [platform, platformEntries] of Object.entries(nativeConfigs)) {
-        const platformSpecs = nativeConfigSpecs[platform];
-        if (!platformSpecs || !platformEntries || typeof platformEntries !== 'object') {
-          continue;
-        }
-
-        for (const [key, entry] of Object.entries(platformEntries)) {
-          const spec = platformSpecs[key];
-          if (!spec) {
-            continue;
-          }
-
+        if (!platformEntries || typeof platformEntries !== 'object') continue;
+        const driver = catalog.driver(platform, 'nativeConfig');
+        if (typeof driver?.importSnapshot === 'function') {
           try {
-            const status = writeNativeConfigAbsolute(spec, entry, overwrite);
-            if (status === 'success') {
-              results.nativeConfigs.success++;
-            } else if (status === 'skipped') {
-              results.nativeConfigs.skipped++;
-            } else {
-              results.nativeConfigs.failed++;
-            }
+            const imported = driver.importSnapshot(platformEntries, { overwrite });
+            results.nativeConfigs.success += imported?.imported ?? imported?.success ?? 0;
+            results.nativeConfigs.skipped += imported?.skipped || 0;
+            results.nativeConfigs.failed += imported?.failed || 0;
           } catch (err) {
-            console.error(`[ConfigImport] 导入 ${platform}.${key} 原生配置失败:`, err);
-            results.nativeConfigs.failed++;
+            console.error(`[ConfigImport] 导入 ${platform} 原生配置失败:`, err);
+            results.nativeConfigs.failed += Object.keys(platformEntries).length;
           }
+          continue;
         }
+        results.nativeConfigs.skipped += Object.keys(platformEntries).length;
       }
     }
 
@@ -2551,10 +2580,10 @@ async function importConfigs(importData, options = {}) {
         }
 
         if (claudeHooks.stopHook !== undefined) {
-          if (!overwrite && fs.existsSync(CLAUDE_SETTINGS_PATH)) {
+          if (!overwrite && fs.existsSync(claudeSettingsPath)) {
             didSkip = true;
           } else {
-            const settings = readJsonFileSafe(CLAUDE_SETTINGS_PATH) || {};
+            const settings = readJsonFileSafe(claudeSettingsPath) || {};
             settings.hooks = settings.hooks || {};
             if (claudeHooks.stopHook) {
               settings.hooks.Stop = claudeHooks.stopHook;
@@ -2564,7 +2593,7 @@ async function importConfigs(importData, options = {}) {
                 delete settings.hooks;
               }
             }
-            writeJsonFileAbsolute(CLAUDE_SETTINGS_PATH, settings, true);
+            writeJsonFileAbsolute(claudeSettingsPath, settings, true);
             didWrite = true;
           }
         }
@@ -2647,5 +2676,7 @@ function generateImportSummary(results) {
 module.exports = {
   exportAllConfigs,
   exportAllConfigsZip,
-  importConfigs
+  importConfigs,
+  exportPlatformSnapshots,
+  getPlatformKeysForType
 };