coding-tool-x 3.8.4 → 3.8.6

package/src/server/services/plugins-service.js

@@ -17,8 +17,12 @@ const { listPlugins, getPlugin, updatePlugin: updatePluginRegistry } = require('
 const { installPlugin: installPluginCore, uninstallPlugin: uninstallPluginCore } = require('../../plugins/plugin-installer');
 const { initializePlugins, shutdownPlugins } = require('../../plugins/plugin-manager');
 const { INSTALLED_DIR, CONFIG_DIR } = require('../../plugins/constants');
-const { NATIVE_PATHS, PATHS } = require('../../config/paths');
-const { OmpNativePluginAdapter } = require('./omp-native-plugin-adapter');
+const pathsModule = require('../../config/paths');
+const { NATIVE_PATHS, PATHS } = pathsModule;
+const getPlatformStatePath = typeof pathsModule.getPlatformStatePath === 'function'
+  ? pathsModule.getPlatformStatePath
+  : (category, platform) => PATHS[category]?.[platform];
+const { OmpNativePluginAdapter } = require('../../platforms/drivers/omp/native-plugin-adapter');
 const {
   importLegacyPluginRepos,
   migratePiStorage
@@ -30,7 +34,7 @@ const {
   normalizeSafeFileStem,
   normalizeSafeRelativePath,
   resolveInsideRoot
-} = require('./config-artifact-paths');
+} = require('../../shared/config-artifact-paths');
 
 const CLAUDE_PLUGINS_DIR = NATIVE_PATHS.claude.plugins
   || path.join(NATIVE_PATHS.claude.dir || path.dirname(NATIVE_PATHS.claude.settings), 'plugins');
@@ -43,6 +47,8 @@ const CODEX_PLUGINS_CACHE_DIR = path.join(CODEX_PLUGINS_DIR, 'cache');
 const OPENCODE_CONFIG_DIR = NATIVE_PATHS.opencode.config;
 const REPO_SOURCE_META_FILE = '.cc-tool-plugin-source.json';
 const SUPPORTED_REPO_PROVIDERS = ['github', 'gitlab', 'local'];
+const PLUGIN_LIST_TTL_MS = 1000;
+const MARKET_CACHE_TTL_MS = 5 * 60 * 1000;
 const DEFAULT_GITHUB_HOST = 'https://github.com';
 const DEFAULT_GITLAB_HOST = 'https://gitlab.com';
 const DEFAULT_REPOS_BY_PLATFORM = {
@@ -116,7 +122,8 @@ const PLATFORM_CAPABILITIES = {
     pluginKindLabel: 'plugins/extensions',
     repositoryMode: 'native-marketplace',
     repositoryToggle: false,
-    repositoryAuth: false
+    repositoryAuth: false,
+    installMetadataMode: 'omp'
   }
 };
 
@@ -435,27 +442,128 @@ function stripJsonComments(input = '') {
 }
 
 class PluginsService {
-  constructor(platform = 'claude') {
+  constructor(platform = 'claude', { registry } = {}) {
     this.platform = resolveManagedPlatform(platform).platform;
+    this.registry = registry || (() => {
+      try {
+        return require('../../platforms/runtime').getPlatformRegistry();
+      } catch {
+        return null;
+      }
+    })();
+    this.pathContext = null;
+    try {
+      if (typeof this.registry?.resolvePathContext === 'function') {
+        this.pathContext = this.registry.resolvePathContext(this.platform);
+      }
+    } catch {
+      this.pathContext = null;
+    }
+    const native = this.pathContext?.customized
+      ? (this.pathContext.native || {})
+      : (NATIVE_PATHS[this.platform] || {});
     this._ompMigrationWarnings = [];
     if (this.platform === 'omp') {
       const migration = migratePiStorage(PATHS);
       this._ompMigrationWarnings.push(...migration.warnings);
     }
     this.configDir = PATHS.config || path.join((PATHS.base || process.env.HOME || os.homedir()), 'config');
-    this.ccToolConfigDir = path.dirname(PATHS.pluginRepos.claude);
-    this.opencodePluginsDir = path.join(OPENCODE_CONFIG_DIR, 'plugins');
-    this.opencodeLegacyPluginsDir = path.join(OPENCODE_CONFIG_DIR, 'plugin');
-    this.codexPluginsCacheDir = CODEX_PLUGINS_CACHE_DIR;
-    this.marketCachePath = PATHS.pluginMarketCache[this.platform] || PATHS.pluginMarketCache.claude;
+    this.ccToolConfigDir = path.dirname(getPlatformStatePath('pluginRepos', this.platform));
+    this.claudePluginsDir = this.platform === 'claude'
+      ? native.plugins || CLAUDE_PLUGINS_DIR
+      : CLAUDE_PLUGINS_DIR;
+    this.claudeInstalledFile = path.join(this.claudePluginsDir, 'installed_plugins.json');
+    this.claudeMarketplacesFile = path.join(this.claudePluginsDir, 'known_marketplaces.json');
+    this.claudePluginsCacheDir = path.join(this.claudePluginsDir, 'cache');
+    this.claudeMarketplacesDir = path.join(this.claudePluginsDir, 'marketplaces');
+    this.codexPluginsDir = this.platform === 'codex'
+      ? path.join(native.dir || path.dirname(native.config || ''), 'plugins')
+      : CODEX_PLUGINS_DIR;
+    this.codexPluginsCacheDir = path.join(this.codexPluginsDir, 'cache');
+    this.opencodeConfigDir = this.platform === 'opencode'
+      ? (native.config || OPENCODE_CONFIG_DIR)
+      : OPENCODE_CONFIG_DIR;
+    this.opencodePluginsDir = path.join(this.opencodeConfigDir, 'plugins');
+    this.opencodeLegacyPluginsDir = path.join(this.opencodeConfigDir, 'plugin');
+    this.marketCachePath = getPlatformStatePath('pluginMarketCache', this.platform);
     this._marketCache = null;
+    this._marketCacheByKey = new Map();
+    this._pluginListCache = new Map();
+    this._pluginListGeneration = 0;
+    this._marketRefreshPromise = null;
+    this._marketFetchedAt = 0;
+    this._marketRepoFingerprint = null;
+    this._marketLastUsedStale = false;
     this.ompNativeAdapter = this.platform === 'omp'
-      ? new OmpNativePluginAdapter()
+      ? new OmpNativePluginAdapter({ pathContext: this.pathContext })
       : null;
   }
 
+  _pluginListKey(options = {}) {
+    const cwd = options.cwd ? path.resolve(options.cwd) : '';
+    const scope = options.scope || '';
+    return `${this.platform}:${cwd}:${scope}`;
+  }
+
+  _clone(value) {
+    if (value === undefined) return value;
+    try {
+      return JSON.parse(JSON.stringify(value));
+    } catch (_) {
+      return value;
+    }
+  }
+
+  _invalidatePluginList(options = null) {
+    this._pluginListGeneration++;
+    if (!options) {
+      this._pluginListCache.clear();
+      return;
+    }
+    const key = this._pluginListKey(options);
+    this._pluginListCache.delete(key);
+  }
+
+
   getCapabilities() {
-    return { ...(PLATFORM_CAPABILITIES[this.platform] || PLATFORM_CAPABILITIES.claude) };
+    return {
+      platform: this.platform,
+      supportsPlugins: false,
+      repositories: false,
+      market: false,
+      install: false,
+      uninstall: false,
+      toggle: false,
+      config: false,
+      import: false,
+      syncRepos: false,
+      ...(PLATFORM_CAPABILITIES[this.platform] || {})
+    };
+  }
+  getRequestOptions(requestData = {}) {
+    return {
+      ...(requestData.cwd ? { cwd: requestData.cwd } : {}),
+      ...(requestData.scope ? { scope: requestData.scope } : {})
+    };
+  }
+
+  normalizeInstallMetadata(requestBody = {}, repoPayload = null) {
+    if (repoPayload) return repoPayload;
+    if (this.getCapabilities().installMetadataMode !== 'omp') return null;
+    const metadata = requestBody.metadata && typeof requestBody.metadata === 'object'
+      ? requestBody.metadata
+      : {};
+    return {
+      ...metadata,
+      name: requestBody.name || metadata.name,
+      pluginId: requestBody.pluginId || metadata.pluginId,
+      pluginKind: requestBody.pluginKind || metadata.pluginKind,
+      marketplace: requestBody.marketplace || metadata.marketplace,
+      installSource: requestBody.installSource || metadata.installSource,
+      version: requestBody.version || metadata.version,
+      description: requestBody.description || metadata.description,
+      resourceTypes: requestBody.resourceTypes || metadata.resourceTypes
+    };
   }
 
   getMigrationWarnings() {
@@ -595,6 +703,10 @@ class PluginsService {
 
   clearMarketCache({ removeFile = true } = {}) {
     this._marketCache = null;
+    this._marketCacheByKey.clear();
+    this._marketFetchedAt = 0;
+    this._marketRepoFingerprint = null;
+    this._invalidatePluginList();
     if (removeFile) {
       try {
         if (fs.existsSync(this.marketCachePath)) {
@@ -606,13 +718,19 @@ class PluginsService {
     }
   }
 
-  loadMarketCacheFromFile() {
+  loadMarketCacheEnvelope() {
     try {
-      if (fs.existsSync(this.marketCachePath)) {
-        const data = JSON.parse(fs.readFileSync(this.marketCachePath, 'utf-8'));
-        if (Array.isArray(data.plugins)) {
-          return data.plugins;
-        }
+      if (!fs.existsSync(this.marketCachePath)) return null;
+      const data = JSON.parse(fs.readFileSync(this.marketCachePath, 'utf-8'));
+      if (Array.isArray(data)) {
+        return { plugins: data, fetchedAt: 0, reposFingerprint: null };
+      }
+      if (Array.isArray(data?.plugins)) {
+        return {
+          plugins: data.plugins,
+          fetchedAt: Number(data.fetchedAt || data.time || 0) || 0,
+          reposFingerprint: typeof data.reposFingerprint === 'string' ? data.reposFingerprint : null
+        };
       }
     } catch (err) {
       // ignore cache read errors
@@ -620,10 +738,22 @@ class PluginsService {
     return null;
   }
 
-  saveMarketCacheToFile(plugins) {
+  loadMarketCacheFromFile() {
+    const cached = this.loadMarketCacheEnvelope();
+    return cached?.fetchedAt && Date.now() - cached.fetchedAt < MARKET_CACHE_TTL_MS
+      ? cached.plugins
+      : null;
+  }
+
+  saveMarketCacheToFile(plugins, fetchedAt = Date.now(), reposFingerprint = null) {
     try {
       this._ensureDir(path.dirname(this.marketCachePath));
-      fs.writeFileSync(this.marketCachePath, JSON.stringify({ plugins }), 'utf-8');
+      fs.writeFileSync(this.marketCachePath, JSON.stringify({
+        fetchedAt,
+        time: fetchedAt,
+        reposFingerprint,
+        plugins
+      }), 'utf-8');
     } catch (err) {
       // ignore cache write errors
     }
@@ -694,9 +824,9 @@ class PluginsService {
   }
 
   _getOpenCodeConfigPath() {
-    const jsonc = path.join(OPENCODE_CONFIG_DIR, 'opencode.jsonc');
-    const json = path.join(OPENCODE_CONFIG_DIR, 'opencode.json');
-    const config = path.join(OPENCODE_CONFIG_DIR, 'config.json');
+    const jsonc = path.join(this.opencodeConfigDir, 'opencode.jsonc');
+    const json = path.join(this.opencodeConfigDir, 'opencode.json');
+    const config = path.join(this.opencodeConfigDir, 'config.json');
     if (fs.existsSync(jsonc)) return jsonc;
     if (fs.existsSync(json)) return json;
     if (fs.existsSync(config)) return config;
@@ -723,6 +853,7 @@ class PluginsService {
   _writeOpenCodeConfig(filePath, config) {
     this._ensureDir(path.dirname(filePath));
     fs.writeFileSync(filePath, JSON.stringify(config, null, 2), 'utf8');
+    this._invalidatePluginList();
   }
 
   _listOpenCodeConfiguredPlugins() {
@@ -850,7 +981,7 @@ class PluginsService {
             marketplace: marketplaceEntry.name,
             version: manifest.version || selectedVersion.name,
             installPath: selectedVersion.fullPath,
-            directory: path.relative(CODEX_PLUGINS_DIR, selectedVersion.fullPath),
+            directory: path.relative(this.codexPluginsDir, selectedVersion.fullPath),
             source: 'codex-cache',
             installed: true,
             enabled: this._isCodexPluginEnabled(manifest.name || pluginEntry.name, marketplaceEntry.name),
@@ -881,7 +1012,9 @@ class PluginsService {
   }
 
   _readCodexConfig() {
-    const filePath = NATIVE_PATHS.codex.config;
+    const filePath = this.pathContext?.customized
+      ? (this.pathContext.native?.config || NATIVE_PATHS.codex.config)
+      : NATIVE_PATHS.codex.config;
     if (!fs.existsSync(filePath)) return { filePath, config: {} };
     try {
       const raw = fs.readFileSync(filePath, 'utf8');
@@ -894,14 +1027,19 @@ class PluginsService {
   }
 
   _writeCodexConfig(config) {
-    const filePath = NATIVE_PATHS.codex.config;
+    const filePath = this.pathContext?.customized
+      ? (this.pathContext.native?.config || NATIVE_PATHS.codex.config)
+      : NATIVE_PATHS.codex.config;
     this._ensureDir(path.dirname(filePath));
     const safeConfig = JSON.parse(JSON.stringify(config || {}));
     fs.writeFileSync(filePath, tomlStringify(safeConfig), 'utf8');
+    this._invalidatePluginList();
   }
 
   _readClaudeSettings() {
-    const filePath = NATIVE_PATHS.claude.settings;
+    const filePath = this.pathContext?.customized
+      ? (this.pathContext.native?.settings || NATIVE_PATHS.claude.settings)
+      : NATIVE_PATHS.claude.settings;
     if (!fs.existsSync(filePath)) return { filePath, settings: {} };
     try {
       const raw = fs.readFileSync(filePath, 'utf8');
@@ -913,9 +1051,12 @@ class PluginsService {
   }
 
   _writeClaudeSettings(settings) {
-    const filePath = NATIVE_PATHS.claude.settings;
+    const filePath = this.pathContext?.customized
+      ? (this.pathContext.native?.settings || NATIVE_PATHS.claude.settings)
+      : NATIVE_PATHS.claude.settings;
     this._ensureDir(path.dirname(filePath));
     fs.writeFileSync(filePath, JSON.stringify(settings || {}, null, 2), 'utf8');
+    this._invalidatePluginList();
   }
 
   _setClaudePluginEnabled(name, marketplace, enabled) {
@@ -967,7 +1108,7 @@ class PluginsService {
 
   _resolveClaudePluginCachePath(marketplace, pluginName, version) {
     return resolveInsideRoot(
-      CLAUDE_PLUGINS_CACHE_DIR,
+      this.claudePluginsCacheDir,
       path.posix.join(
         normalizeClaudeMarketplaceSegment(marketplace),
         normalizePluginCacheSegment(pluginName, 'Claude plugin name', 'plugin'),
@@ -979,7 +1120,7 @@ class PluginsService {
 
   _resolveClaudeMarketplacePath(marketplace) {
     return resolveInsideRoot(
-      CLAUDE_MARKETPLACES_DIR,
+      this.claudeMarketplacesDir,
       normalizeClaudeMarketplaceSegment(marketplace),
       'Claude marketplace path'
     );
@@ -1000,11 +1141,11 @@ class PluginsService {
     };
     fs.writeFileSync(manifestPath, JSON.stringify(marketplaceManifest, null, 2), 'utf8');
 
-    this._ensureDir(CLAUDE_PLUGINS_DIR);
+    this._ensureDir(this.claudePluginsDir);
     let known = {};
-    if (fs.existsSync(CLAUDE_MARKETPLACES_FILE)) {
+    if (fs.existsSync(this.claudeMarketplacesFile)) {
       try {
-        known = JSON.parse(fs.readFileSync(CLAUDE_MARKETPLACES_FILE, 'utf8'));
+        known = JSON.parse(fs.readFileSync(this.claudeMarketplacesFile, 'utf8'));
       } catch {
         known = {};
       }
@@ -1017,7 +1158,7 @@ class PluginsService {
       installLocation: marketplaceDir,
       lastUpdated: new Date().toISOString()
     };
-    fs.writeFileSync(CLAUDE_MARKETPLACES_FILE, JSON.stringify(known, null, 2), 'utf8');
+    fs.writeFileSync(this.claudeMarketplacesFile, JSON.stringify(known, null, 2), 'utf8');
 
     const { settings } = this._readClaudeSettings();
     const nextSettings = (settings && typeof settings === 'object') ? { ...settings } : {};
@@ -1085,11 +1226,11 @@ class PluginsService {
   }
 
   _registerClaudeInstalledPlugin(name, marketplace, installPath, installData = {}) {
-    this._ensureDir(CLAUDE_PLUGINS_DIR);
+    this._ensureDir(this.claudePluginsDir);
     let nativeData = { version: 2, plugins: {} };
-    if (fs.existsSync(CLAUDE_INSTALLED_FILE)) {
+    if (fs.existsSync(this.claudeInstalledFile)) {
       try {
-        nativeData = JSON.parse(fs.readFileSync(CLAUDE_INSTALLED_FILE, 'utf8'));
+        nativeData = JSON.parse(fs.readFileSync(this.claudeInstalledFile, 'utf8'));
       } catch {
         nativeData = { version: 2, plugins: {} };
       }
@@ -1109,7 +1250,8 @@ class PluginsService {
       ...(installData.source ? { source: installData.source } : {}),
       ...(installData.repoSourceMeta || {})
     }];
-    fs.writeFileSync(CLAUDE_INSTALLED_FILE, JSON.stringify(nativeData, null, 2), 'utf8');
+    fs.writeFileSync(this.claudeInstalledFile, JSON.stringify(nativeData, null, 2), 'utf8');
+    this._invalidatePluginList();
     this._setClaudePluginEnabled(name, marketplace, true);
   }
 
@@ -1176,12 +1318,31 @@ class PluginsService {
     return slugifyCodexKey(repo.name || repo.owner || 'github');
   }
 
+  listPlugins(options = {}) {
+    const key = this._pluginListKey(options);
+    const now = Date.now();
+    const cached = this._pluginListCache.get(key);
+    if (!options.force && cached
+      && now - cached.cachedAt < PLUGIN_LIST_TTL_MS
+      && cached.generation === this._pluginListGeneration) {
+      return this._clone(cached.value);
+    }
+
+    const value = this._listPluginsUncached(options);
+    this._pluginListCache.set(key, {
+      value: this._clone(value),
+      cachedAt: now,
+      generation: this._pluginListGeneration
+    });
+    return this._clone(value);
+  }
+
   /**
    * List all installed plugins with their status
    * Reads from Claude Code's native installed_plugins.json
    * @returns {Object} { plugins: Array }
    */
-  listPlugins(options = {}) {
+  _listPluginsUncached(options = {}) {
     if (!this._pluginsSupported()) {
       return { plugins: [] };
     }
@@ -1224,11 +1385,32 @@ class PluginsService {
     }
 
     const plugins = [];
+    const legacyPlugins = (() => {
+      try {
+        return listPlugins();
+      } catch {
+        return [];
+      }
+    })();
+    const legacyByName = new Map(legacyPlugins.map(plugin => [plugin.name, plugin]));
+    const claudeSettings = this._readClaudeSettings().settings || {};
+    const enabledPlugins = claudeSettings.enabledPlugins || {};
+    const isEnabled = (name, marketplace) => {
+      const exactKey = marketplace ? `${name}@${marketplace}` : name;
+      if (Object.prototype.hasOwnProperty.call(enabledPlugins, exactKey)) {
+        return enabledPlugins[exactKey] !== false;
+      }
+      for (const [key, value] of Object.entries(enabledPlugins)) {
+        const parsed = splitPluginMarketplaceKey(key);
+        if (parsed.name === name) return value !== false;
+      }
+      return true;
+    };
 
     // Read Claude Code's installed_plugins.json
-    if (fs.existsSync(CLAUDE_INSTALLED_FILE)) {
+    if (fs.existsSync(this.claudeInstalledFile)) {
       try {
-        const data = JSON.parse(fs.readFileSync(CLAUDE_INSTALLED_FILE, 'utf8'));
+        const data = JSON.parse(fs.readFileSync(this.claudeInstalledFile, 'utf8'));
         if (data.plugins) {
           for (const [key, installations] of Object.entries(data.plugins)) {
             if (installations && installations.length > 0) {
@@ -1285,9 +1467,10 @@ class PluginsService {
               }
 
               // Read enabled state from CTX registry (defaults to true if not set)
-              const legacyInfo = getPlugin(name);
-              const enabledState = this._isClaudePluginEnabled(name, marketplace) &&
-                (legacyInfo ? legacyInfo.enabled !== false : true);
+              // Project settings and legacy registry are loaded once per list call.
+              const legacyInfo = legacyByName.get(name);
+              const enabledState = isEnabled(name, marketplace)
+                && (legacyInfo ? legacyInfo.enabled !== false : true);
 
               plugins.push({
                 name,
@@ -1319,16 +1502,11 @@ class PluginsService {
       }
     }
 
-    // Also check legacy registry
-    try {
-      const legacyPlugins = listPlugins();
-      for (const plugin of legacyPlugins) {
-        if (!plugins.find(p => p.name === plugin.name)) {
-          plugins.push(plugin);
-        }
+    // Add registry-only plugins without rereading the registry.
+    for (const plugin of legacyPlugins) {
+      if (!plugins.find(existing => existing.name === plugin.name)) {
+        plugins.push(plugin);
       }
-    } catch (err) {
-      // Ignore legacy registry errors
     }
 
     return { plugins };
@@ -1442,7 +1620,9 @@ class PluginsService {
         || metadata.installSource
         || ''
       ).trim();
-      return this.ompNativeAdapter.installPlugin(target, metadata, options);
+      const result = this.ompNativeAdapter.installPlugin(target, metadata, options);
+      this._invalidatePluginList(options);
+      return result;
     }
 
     if (this._isOpenCode()) {
@@ -1868,9 +2048,10 @@ class PluginsService {
         error: `${this.platform} plugin management is not supported`
       };
     }
-
     if (this._isOmp()) {
-      return this.ompNativeAdapter.uninstallPlugin(name, options);
+      const result = this.ompNativeAdapter.uninstallPlugin(name, options);
+      this._invalidatePluginList(options);
+      return result;
     }
 
     if (this._isOpenCode()) {
@@ -1915,9 +2096,9 @@ class PluginsService {
     // Claude: Remove from native installed_plugins.json and delete install directories
     let removed = false;
     const safeName = normalizePluginPathName(name, 'plugin name');
-    if (fs.existsSync(CLAUDE_INSTALLED_FILE)) {
+    if (fs.existsSync(this.claudeInstalledFile)) {
       try {
-        const data = JSON.parse(fs.readFileSync(CLAUDE_INSTALLED_FILE, 'utf8'));
+        const data = JSON.parse(fs.readFileSync(this.claudeInstalledFile, 'utf8'));
         if (data.plugins) {
           const keysToDelete = [];
           const baseName = safeName.split('/').pop(); // handle "plugins/pr-review-toolkit" → "pr-review-toolkit"
@@ -1932,7 +2113,7 @@ class PluginsService {
                     try {
                       const installPath = assertInsideAllowedRoots(
                         install.installPath,
-                        [INSTALLED_DIR, CLAUDE_PLUGINS_DIR],
+                        [INSTALLED_DIR, this.claudePluginsDir],
                         'Claude plugin install path'
                       );
                       fs.rmSync(installPath, { recursive: true, force: true });
@@ -1950,7 +2131,8 @@ class PluginsService {
               this._removeClaudePluginEnabled(parsed.name || safeName, parsed.marketplace || '');
               delete data.plugins[key];
             }
-            fs.writeFileSync(CLAUDE_INSTALLED_FILE, JSON.stringify(data, null, 2), 'utf8');
+            fs.writeFileSync(this.claudeInstalledFile, JSON.stringify(data, null, 2), 'utf8');
+            this._invalidatePluginList();
             removed = true;
           }
         }
@@ -2006,7 +2188,9 @@ class PluginsService {
     }
 
     if (this._isOmp()) {
-      return this.ompNativeAdapter.togglePlugin(name, enabled, options);
+      const result = this.ompNativeAdapter.togglePlugin(name, enabled, options);
+      this._invalidatePluginList(options);
+      return result;
     }
 
     if (this._isOpenCode()) {
@@ -2029,9 +2213,9 @@ class PluginsService {
     // First check if plugin exists in native installed_plugins.json
     let pluginExists = false;
     const baseName = name.split('/').pop();
-    if (fs.existsSync(CLAUDE_INSTALLED_FILE)) {
+    if (fs.existsSync(this.claudeInstalledFile)) {
       try {
-        const data = JSON.parse(fs.readFileSync(CLAUDE_INSTALLED_FILE, 'utf8'));
+        const data = JSON.parse(fs.readFileSync(this.claudeInstalledFile, 'utf8'));
         if (data.plugins) {
           for (const key of Object.keys(data.plugins)) {
             const { name: pluginName } = splitPluginMarketplaceKey(key);
@@ -2064,9 +2248,9 @@ class PluginsService {
     } catch (e) {
       console.warn('[PluginsService] Failed to update plugin registry:', e.message);
     }
-    if (fs.existsSync(CLAUDE_INSTALLED_FILE)) {
+    if (fs.existsSync(this.claudeInstalledFile)) {
       try {
-        const data = JSON.parse(fs.readFileSync(CLAUDE_INSTALLED_FILE, 'utf8'));
+        const data = JSON.parse(fs.readFileSync(this.claudeInstalledFile, 'utf8'));
         for (const key of Object.keys(data.plugins || {})) {
           const parsed = splitPluginMarketplaceKey(key);
           if (parsed.name === name || key === name || parsed.name === baseName) {
@@ -2103,11 +2287,13 @@ class PluginsService {
     }
 
     if (this._isOmp()) {
-      return this.ompNativeAdapter.updatePluginConfig(name, config, options);
+      const result = this.ompNativeAdapter.updatePluginConfig(name, config, options);
+      this._invalidatePluginList(options);
+      return result;
     }
 
     if (this._isOpenCode()) {
-      const configDir = path.join(OPENCODE_CONFIG_DIR, 'plugins-config');
+      const configDir = path.join(this.opencodeConfigDir, 'plugins-config');
       const configFile = resolvePluginConfigFile(configDir, name);
       this._ensureDir(path.dirname(configFile));
       fs.writeFileSync(configFile, JSON.stringify(config, null, 2), 'utf8');
@@ -2142,13 +2328,14 @@ class PluginsService {
    * @returns {string} Config file path
    */
   getReposConfigPath() {
-    const filePath = PATHS.pluginRepos[this.platform] || PATHS.pluginRepos.claude;
+    const filePath = getPlatformStatePath('pluginRepos', this.platform);
+    if (!filePath) throw new Error(`Plugin repository path is not configured for ${this.platform}`);
     this._ensureDir(path.dirname(filePath));
     return filePath;
   }
 
   _getDefaultRepos() {
-    return cloneRepos(DEFAULT_REPOS_BY_PLATFORM[this.platform] || DEFAULT_REPOS_BY_PLATFORM.claude);
+    return cloneRepos(DEFAULT_REPOS_BY_PLATFORM[this.platform] || []);
   }
 
   /**
@@ -2227,9 +2414,9 @@ class PluginsService {
     }
 
     // 2. Load Claude Code's native marketplace config (Claude only)
-    if (this.platform === 'claude' && fs.existsSync(CLAUDE_MARKETPLACES_FILE)) {
+    if (this.platform === 'claude' && fs.existsSync(this.claudeMarketplacesFile)) {
       try {
-        const marketplaces = JSON.parse(fs.readFileSync(CLAUDE_MARKETPLACES_FILE, 'utf8'));
+        const marketplaces = JSON.parse(fs.readFileSync(this.claudeMarketplacesFile, 'utf8'));
         const entries = [];
         if (Array.isArray(marketplaces)) {
           entries.push(...marketplaces.map(item => ({ key: '', data: item })));
@@ -2975,45 +3162,46 @@ class PluginsService {
     };
   }
 
-  async _fetchOpenCodeMarketplacePlugins(repo, branch) {
+  async _fetchOpenCodeMarketplacePlugins(repo, branch, tree = null) {
     if (!this._isOpenCode()) return [];
 
-    const tree = await this.fetchRepoTree(repo);
-    const manifestFiles = tree.filter(item =>
+    const sourceTree = tree || await this.fetchRepoTree(repo);
+    const manifestFiles = sourceTree.filter(item =>
       item.type === 'blob' &&
       item.path.startsWith('plugins/') &&
       item.path.endsWith('.plugin.json')
     );
     if (manifestFiles.length === 0) return [];
 
-    const results = await Promise.allSettled(
-      manifestFiles.map(async (file) => {
-        const manifest = await this.fetchRepoJson(repo, file.path, file);
-
-        const author = Array.isArray(manifest.authors)
-          ? manifest.authors.map(item => item?.name).filter(Boolean).join(', ')
-          : '';
-        const firstCategory = Array.isArray(manifest.categories) ? manifest.categories[0] : '';
-        const repoUrl = manifest.links?.repository || `https://github.com/${repo.owner}/${repo.name}`;
-        // OpenCode supports npm package plugins via opencode.json "plugin" array.
-        // Use package name as install source so UI install button is enabled.
-        const installSource = String(manifest.name || '').trim();
-        const githubRepo = this._parseGitHubRepo(repoUrl);
-
-        return this.buildMarketPluginItem(repo, {
-          name: manifest.name || file.name.replace(/\.plugin\.json$/, ''),
-          displayName: manifest.displayName || '',
-          description: manifest.description || '',
-          author: author || repo.owner,
-          version: manifest.version || manifest.opencode?.minimumVersion || '1.0.0',
-          category: firstCategory ? String(firstCategory).toLowerCase() : 'general',
-          directory: file.path,
-          installSource,
-          marketplaceFormat: 'opencode-plugin-json',
-          repoUrl
-        });
-      })
-    );
+    const results = [];
+    for (let start = 0; start < manifestFiles.length; start += 5) {
+      const batch = manifestFiles.slice(start, start + 5);
+      results.push(...await Promise.allSettled(
+        batch.map(async (file) => {
+          const manifest = await this.fetchRepoJson(repo, file.path, file);
+
+          const author = Array.isArray(manifest.authors)
+            ? manifest.authors.map(item => item?.name).filter(Boolean).join(', ')
+            : '';
+          const firstCategory = Array.isArray(manifest.categories) ? manifest.categories[0] : '';
+          const repoUrl = manifest.links?.repository || `https://github.com/${repo.owner}/${repo.name}`;
+          const installSource = String(manifest.name || '').trim();
+
+          return this.buildMarketPluginItem(repo, {
+            name: manifest.name || file.name.replace(/\.plugin\.json$/, ''),
+            displayName: manifest.displayName || '',
+            description: manifest.description || '',
+            author: author || repo.owner,
+            version: manifest.version || manifest.opencode?.minimumVersion || '1.0.0',
+            category: firstCategory ? String(firstCategory).toLowerCase() : 'general',
+            directory: file.path,
+            installSource,
+            marketplaceFormat: 'opencode-plugin-json',
+            repoUrl
+          });
+        })
+      ));
+    }
 
     return results
       .filter(item => item.status === 'fulfilled' && item.value)
@@ -3219,14 +3407,85 @@ class PluginsService {
     return results;
   }
 
+  _marketKey(options = {}) {
+    return `${this.platform}:${options.cwd ? path.resolve(options.cwd) : ''}:${options.scope || ''}`;
+  }
+
+  _marketReposFingerprint(repos) {
+    return JSON.stringify((repos || []).map(repo => ({
+      id: repo.id || '',
+      enabled: repo.enabled !== false,
+      source: repo.source || repo.repoUrl || repo.localPath || ''
+    })));
+  }
+
+  async getMarketPlugins(forceRefresh = false, options = {}) {
+    if (!this.getCapabilities().market) return [];
+    const key = this._marketKey(options);
+    const repos = this._isOmp() ? [] : this.getRepos(options).filter(repo => repo.enabled);
+    const reposFingerprint = this._marketReposFingerprint(repos);
+    const now = Date.now();
+    const cached = this._marketCacheByKey.get(key);
+    const memoryPlugins = Array.isArray(cached?.plugins)
+      ? cached.plugins
+      : (Array.isArray(this._marketCache) ? this._marketCache : null);
+    if (!forceRefresh && cached && now - cached.fetchedAt < MARKET_CACHE_TTL_MS
+      && cached.reposFingerprint === reposFingerprint) {
+      return this._clone(cached.plugins);
+    }
+
+    const disk = this.loadMarketCacheEnvelope();
+    if (!forceRefresh && Array.isArray(disk?.plugins)) {
+      const diskPlugins = this.prepareMarketPlugins(disk.plugins);
+      const diskIsFresh = disk.fetchedAt
+        && now - disk.fetchedAt < MARKET_CACHE_TTL_MS
+        && (!disk.reposFingerprint || disk.reposFingerprint === reposFingerprint);
+      const diskIsMoreComplete = memoryPlugins && diskPlugins.length > memoryPlugins.length;
+      if (diskIsFresh || diskIsMoreComplete) {
+        this._marketCacheByKey.set(key, {
+          plugins: diskPlugins,
+          fetchedAt: disk.fetchedAt,
+          reposFingerprint: disk.reposFingerprint || reposFingerprint
+        });
+        this._marketCache = diskPlugins;
+        this._marketFetchedAt = disk.fetchedAt;
+        this._marketRepoFingerprint = disk.reposFingerprint || reposFingerprint;
+        return this._clone(diskPlugins);
+      }
+    }
+
+    if (this._marketRefreshPromise) return this._marketRefreshPromise;
+    const promise = this._getMarketPluginsUncached(forceRefresh, options, { reposFingerprint })
+      .then(plugins => {
+        this._marketCache = Array.isArray(plugins) ? plugins : [];
+        this._marketFetchedAt = this._marketLastUsedStale ? 0 : Date.now();
+        this._marketRepoFingerprint = reposFingerprint;
+        this._marketCacheByKey.set(key, {
+          plugins: this._marketCache,
+          fetchedAt: this._marketFetchedAt,
+          reposFingerprint
+        });
+        if (!this._marketLastUsedStale) {
+          this.saveMarketCacheToFile(this._marketCache, this._marketFetchedAt, reposFingerprint);
+        }
+        return this._clone(this._marketCache);
+      })
+      .finally(() => {
+        if (this._marketRefreshPromise === promise) this._marketRefreshPromise = null;
+      });
+    this._marketRefreshPromise = promise;
+    return promise;
+  }
+
   /**
    * Get market plugins from configured repositories
    * @returns {Promise<Array>} List of available market plugins
    */
-  async getMarketPlugins(forceRefresh = false, options = {}) {
+  async _getMarketPluginsUncached(forceRefresh = false, options = {}, { reposFingerprint = null } = {}) {
     if (!this.getCapabilities().market) {
       return [];
     }
+    this._marketLastUsedStale = false;
     if (this._isOmp()) {
       if (forceRefresh) {
         this.ompNativeAdapter.updateMarketplaces('', options);
@@ -3238,27 +3497,16 @@ class PluginsService {
       this.clearMarketCache({ removeFile: false });
     }
 
-    const fileCache = this.loadMarketCacheFromFile();
-
-    if (!forceRefresh && Array.isArray(this._marketCache) && this._marketCache.length > 0) {
-      if (Array.isArray(fileCache) && fileCache.length > this._marketCache.length) {
-        this._marketCache = this.prepareMarketPlugins(fileCache);
-        return this._marketCache;
-      }
-      this._marketCache = this.prepareMarketPlugins(this._marketCache);
-      return this._marketCache;
-    }
-
-    if (!forceRefresh && Array.isArray(fileCache) && fileCache.length > 0) {
-      this._marketCache = this.prepareMarketPlugins(fileCache);
-      return this._marketCache;
-    }
+    const fileCache = this.loadMarketCacheEnvelope()?.plugins || null;
 
     const repos = this.getRepos().filter(r => r.enabled);
     const marketPlugins = [];
     let repoFailureCount = 0;
 
-    for (const repo of repos) {
+    let nextRepoIndex = 0;
+    const processRepo = async () => {
+      while (nextRepoIndex < repos.length) {
+        const repo = repos[nextRepoIndex++];
       const repoLabel = repo.label || repo.repoUrl || repo.localPath || `${repo.owner || ''}/${repo.name || ''}`;
       const pluginsBefore = marketPlugins.length;
       try {
@@ -3294,7 +3542,7 @@ class PluginsService {
 
         // OpenCode plugin marketplace format: plugins/*.plugin.json
         if (this._isOpenCode()) {
-          const openCodeMarketplacePlugins = await this._fetchOpenCodeMarketplacePlugins(repo, repo.branch || 'main');
+          const openCodeMarketplacePlugins = await this._fetchOpenCodeMarketplacePlugins(repo, repo.branch || 'main', tree);
           if (openCodeMarketplacePlugins.length > 0) {
             marketPlugins.push(...openCodeMarketplacePlugins);
             continue;
@@ -3344,7 +3592,9 @@ class PluginsService {
             .filter(dir => dir && !dir.startsWith('.') && dir !== 'node_modules')
         ));
 
-        for (const dir of pluginDirs) {
+        for (let batchStart = 0; batchStart < pluginDirs.length; batchStart += 5) {
+          const batch = pluginDirs.slice(batchStart, batchStart + 5);
+          await Promise.all(batch.map(async (dir) => {
           try {
             const manifest = await readJson(`${dir}/plugin.json`);
             if (!manifest) {
@@ -3377,6 +3627,7 @@ class PluginsService {
               }
             }
           }
+          }));
         }
       } catch (err) {
         repoFailureCount++;
@@ -3386,6 +3637,8 @@ class PluginsService {
       const added = marketPlugins.length - pluginsBefore;
       console.log(`[PluginsService] ${repoLabel}: ${added} plugins loaded`);
     }
+    };
+    await Promise.all(Array.from({ length: Math.min(3, repos.length) }, () => processRepo()));
 
     const preparedPlugins = this.prepareMarketPlugins(marketPlugins);
     const preparedFileCache = Array.isArray(fileCache) && fileCache.length > 0
@@ -3397,12 +3650,13 @@ class PluginsService {
     );
 
     if (shouldUseStaleFileCache) {
+      this._marketLastUsedStale = true;
       this._marketCache = preparedFileCache;
       return this._marketCache;
     }
 
     this._marketCache = preparedPlugins;
-    this.saveMarketCacheToFile(preparedPlugins);
+    this.saveMarketCacheToFile(preparedPlugins, Date.now(), reposFingerprint);
 
     return preparedPlugins;
   }