coding-tool-x 3.5.9 → 3.5.10

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

@@ -18,15 +18,10 @@ const { INSTALLED_DIR, CONFIG_DIR } = require('../../plugins/constants');
 const { NATIVE_PATHS, PATHS } = require('../../config/paths');
 const { maskToken } = require('./oauth-utils');
 
-const CLAUDE_PLUGINS_DIR = NATIVE_PATHS.claude.plugins;
-const CLAUDE_INSTALLED_FILE = NATIVE_PATHS.claude.installedPlugins;
-const CLAUDE_MARKETPLACES_FILE = NATIVE_PATHS.claude.pluginMarketplaces;
-const OPENCODE_PLUGINS_DIR = NATIVE_PATHS.opencode.plugins;
-const OPENCODE_LEGACY_PLUGINS_DIR = NATIVE_PATHS.opencode.pluginsLegacy;
-const OPENCODE_CONFIG_JSONC = NATIVE_PATHS.opencode.configJsonc;
-const OPENCODE_CONFIG_JSON = NATIVE_PATHS.opencode.configJson;
-const OPENCODE_CONFIG_LEGACY = NATIVE_PATHS.opencode.configLegacy;
-const OPENCODE_PLUGINS_CONFIG_DIR = NATIVE_PATHS.opencode.pluginsConfig;
+const CLAUDE_PLUGINS_DIR = path.join(path.dirname(NATIVE_PATHS.claude.settings), 'plugins');
+const CLAUDE_INSTALLED_FILE = path.join(CLAUDE_PLUGINS_DIR, 'installed_plugins.json');
+const CLAUDE_MARKETPLACES_FILE = path.join(CLAUDE_PLUGINS_DIR, 'known_marketplaces.json');
+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 DEFAULT_GITHUB_HOST = 'https://github.com';
@@ -35,15 +30,6 @@ const DEFAULT_REPOS_BY_PLATFORM = {
   claude: [],
   opencode: []
 };
-const MAX_PLUGIN_FILE_PREVIEW_BYTES = 256 * 1024;
-const TEXT_PREVIEW_EXTENSIONS = new Set([
-  '.md', '.txt', '.json', '.jsonc', '.js', '.cjs', '.mjs', '.ts', '.jsx', '.tsx', '.vue',
-  '.css', '.scss', '.sass', '.less', '.html', '.xml', '.svg', '.py', '.sh', '.bash', '.zsh',
-  '.yaml', '.yml', '.toml', '.ini', '.conf', '.cfg', '.env', '.sample', '.gitignore', '.npmignore'
-]);
-const TEXT_PREVIEW_BASENAMES = new Set([
-  'README', 'README.md', 'readme.md', 'LICENSE', 'Dockerfile', 'Makefile', 'SKILL.md'
-]);
 
 function cloneRepos(repos = []) {
   return repos.map(repo => ({ ...repo }));
@@ -222,538 +208,17 @@ function stripJsonComments(input = '') {
   return result;
 }
 
-function isPlainObject(value) {
-  return !!value && typeof value === 'object' && !Array.isArray(value);
-}
-
-function getNestedValue(source, segments = []) {
-  return segments.reduce((acc, segment) => (acc && acc[segment] !== undefined ? acc[segment] : undefined), source);
-}
-
-function normalizeContentText(value = '') {
-  return String(value || '').trim();
-}
-
-function normalizeContentEntry(raw, fallback = {}) {
-  if (typeof raw === 'string') {
-    const name = normalizeContentText(raw);
-    if (!name) return null;
-    return {
-      name,
-      path: normalizeRepoPath(fallback.path || ''),
-      description: normalizeContentText(fallback.description || '')
-    };
-  }
-
-  if (!isPlainObject(raw)) {
-    return null;
-  }
-
-  const candidateName = [
-    raw.name,
-    raw.displayName,
-    raw.id,
-    raw.title,
-    raw.fileName,
-    raw.directory,
-    raw.path,
-    fallback.name
-  ].map(normalizeContentText).find(Boolean) || '';
-  const itemPath = normalizeRepoPath(raw.path || raw.file || raw.fileName || raw.directory || fallback.path || '');
-  const description = normalizeContentText(raw.description || raw.prompt || raw.usage || fallback.description || '');
-  const derivedName = candidateName || (itemPath ? path.posix.basename(itemPath, path.posix.extname(itemPath)) : '');
-
-  if (!derivedName && !itemPath) {
-    return null;
-  }
-
-  return {
-    name: derivedName,
-    path: itemPath,
-    description
-  };
-}
-
-function normalizeContentCollection(value, fallback = {}) {
-  if (Array.isArray(value)) {
-    return value.map(item => normalizeContentEntry(item, fallback)).filter(Boolean);
-  }
-
-  if (isPlainObject(value)) {
-    return Object.entries(value)
-      .map(([key, item]) => {
-        if (isPlainObject(item)) {
-          return normalizeContentEntry({
-            ...item,
-            name: item.name || key
-          }, fallback);
-        }
-
-        if (typeof item === 'string') {
-          return normalizeContentEntry({
-            name: key,
-            description: item
-          }, fallback);
-        }
-
-        return normalizeContentEntry({ name: key }, fallback);
-      })
-      .filter(Boolean);
-  }
-
-  return [];
-}
-
-function mergeContentCollections(...collections) {
-  const merged = [];
-  const seen = new Set();
-
-  for (const collection of collections) {
-    for (const rawEntry of collection || []) {
-      const entry = normalizeContentEntry(rawEntry);
-      if (!entry) continue;
-
-      const normalizedPath = normalizeRepoPath(entry.path || '');
-      const normalizedName = normalizeContentText(entry.name || '');
-      const key = normalizedPath
-        ? `path:${normalizedPath.toLowerCase()}`
-        : (normalizedName ? `name:${normalizedName.toLowerCase()}` : '');
-
-      if (!key || seen.has(key)) {
-        continue;
-      }
-
-      seen.add(key);
-      merged.push({
-        name: normalizedName || path.posix.basename(normalizedPath, path.posix.extname(normalizedPath)),
-        path: normalizedPath,
-        description: normalizeContentText(entry.description || '')
-      });
-    }
-  }
-
-  return merged.sort((a, b) => {
-    const left = a.name || a.path;
-    const right = b.name || b.path;
-    return left.localeCompare(right);
-  });
-}
-
 class PluginsService {
   constructor(platform = 'claude') {
     this.platform = ['claude', 'opencode'].includes(platform) ? platform : 'claude';
     this.configDir = PATHS.config || path.join((PATHS.base || process.env.HOME || os.homedir()), 'config');
     this.ccToolConfigDir = path.dirname(PATHS.pluginRepos.claude);
-    this.storageDir = this.platform === 'opencode'
-      ? PATHS.localPlugins.opencode
-      : PATHS.localPlugins.claude;
-    this.opencodePluginsDir = OPENCODE_PLUGINS_DIR;
-    this.opencodeLegacyPluginsDir = OPENCODE_LEGACY_PLUGINS_DIR;
+    this.opencodePluginsDir = path.join(OPENCODE_CONFIG_DIR, 'plugins');
+    this.opencodeLegacyPluginsDir = path.join(OPENCODE_CONFIG_DIR, 'plugin');
     this.marketCachePath = this.platform === 'opencode'
       ? PATHS.pluginMarketCache.opencode
       : PATHS.pluginMarketCache.claude;
     this._marketCache = null;
-    this._ensureDir(this.storageDir);
-  }
-
-  _createEmptyContentSummary() {
-    return {
-      skills: [],
-      agents: [],
-      commands: [],
-      hooks: [],
-      files: [],
-      totalFiles: 0,
-      additionalFileCount: 0
-    };
-  }
-
-  _getManifestCollection(manifest = null, paths = []) {
-    if (!isPlainObject(manifest)) {
-      return [];
-    }
-
-    return mergeContentCollections(
-      ...paths.map(segments => normalizeContentCollection(getNestedValue(manifest, segments)))
-    );
-  }
-
-  _summarizeManifestContent(manifest = null) {
-    const emptySummary = this._createEmptyContentSummary();
-    if (!isPlainObject(manifest)) {
-      return emptySummary;
-    }
-
-    return {
-      ...emptySummary,
-      skills: this._getManifestCollection(manifest, [
-        ['skills'],
-        ['ctx', 'skills'],
-        ['contributes', 'skills']
-      ]),
-      agents: this._getManifestCollection(manifest, [
-        ['agents'],
-        ['ctx', 'agents'],
-        ['contributes', 'agents']
-      ]),
-      commands: this._getManifestCollection(manifest, [
-        ['commands'],
-        ['ctx', 'commands'],
-        ['contributes', 'commands']
-      ]),
-      hooks: this._getManifestCollection(manifest, [
-        ['hooks'],
-        ['ctx', 'hooks'],
-        ['contributes', 'hooks']
-      ])
-    };
-  }
-
-  _getScopedFileContext(files = [], directory = '') {
-    const normalizedDirectory = normalizeRepoPath(directory);
-    const directoryLooksLikeFile = /\.[a-z0-9]+$/i.test(path.posix.basename(normalizedDirectory || ''));
-    const allFiles = (Array.isArray(files) ? files : [])
-      .filter(item => item && item.type === 'blob' && item.path)
-      .map(item => ({
-        ...item,
-        path: normalizeRepoPath(item.path)
-      }))
-      .sort((a, b) => a.path.localeCompare(b.path));
-
-    let scopedFiles = allFiles;
-    if (normalizedDirectory) {
-      if (directoryLooksLikeFile) {
-        scopedFiles = allFiles.filter(item => item.path === normalizedDirectory);
-      } else {
-        const directoryPrefix = `${normalizedDirectory}/`;
-        scopedFiles = allFiles.filter(item => item.path.startsWith(directoryPrefix));
-      }
-    }
-
-    const toScopedPath = (filePath = '') => {
-      const normalizedFilePath = normalizeRepoPath(filePath);
-      if (!normalizedDirectory || directoryLooksLikeFile) {
-        return normalizedFilePath;
-      }
-      const prefix = `${normalizedDirectory}/`;
-      return normalizedFilePath.startsWith(prefix) ? normalizedFilePath.slice(prefix.length) : normalizedFilePath;
-    };
-
-    return {
-      normalizedDirectory,
-      directoryLooksLikeFile,
-      allFiles,
-      scopedFiles,
-      toScopedPath
-    };
-  }
-
-  _summarizeContentFromFiles(files = [], directory = '') {
-    const emptySummary = this._createEmptyContentSummary();
-    const { scopedFiles, toScopedPath } = this._getScopedFileContext(files, directory);
-
-    const skillEntries = [];
-    const agentEntries = [];
-    const commandEntries = [];
-
-    for (const file of scopedFiles) {
-      const scopedPath = toScopedPath(file.path);
-      const skillMatch = scopedPath.match(/^skills\/([^/]+)\/SKILL\.md$/i);
-      if (skillMatch) {
-        skillEntries.push({ name: skillMatch[1], path: scopedPath });
-      }
-
-      const agentMatch = scopedPath.match(/^agents\/(.+)\.md$/i);
-      if (agentMatch) {
-        agentEntries.push({
-          name: agentMatch[1].split('/').pop(),
-          path: scopedPath
-        });
-      }
-
-      const commandMatch = scopedPath.match(/^(?:commands|prompts)\/(.+)\.md$/i);
-      if (commandMatch) {
-        commandEntries.push({
-          name: commandMatch[1].split('/').pop(),
-          path: scopedPath
-        });
-      }
-    }
-
-    const filePreview = scopedFiles.slice(0, 8).map(file => {
-      const scopedPath = toScopedPath(file.path);
-      return {
-        name: path.posix.basename(scopedPath),
-        path: scopedPath
-      };
-    });
-
-    return {
-      ...emptySummary,
-      skills: mergeContentCollections(skillEntries),
-      agents: mergeContentCollections(agentEntries),
-      commands: mergeContentCollections(commandEntries),
-      files: filePreview,
-      totalFiles: scopedFiles.length,
-      additionalFileCount: Math.max(0, scopedFiles.length - filePreview.length)
-    };
-  }
-
-  _mergeContentSummary(...summaries) {
-    const emptySummary = this._createEmptyContentSummary();
-    const validSummaries = summaries.filter(Boolean);
-    const fileSummary = validSummaries.find(summary => Array.isArray(summary.files) && summary.files.length > 0) || emptySummary;
-
-    return {
-      ...emptySummary,
-      skills: mergeContentCollections(...validSummaries.map(summary => summary.skills)),
-      agents: mergeContentCollections(...validSummaries.map(summary => summary.agents)),
-      commands: mergeContentCollections(...validSummaries.map(summary => summary.commands)),
-      hooks: mergeContentCollections(...validSummaries.map(summary => summary.hooks)),
-      files: fileSummary.files || [],
-      totalFiles: fileSummary.totalFiles || 0,
-      additionalFileCount: fileSummary.additionalFileCount || 0
-    };
-  }
-
-  _scanInstallPath(installPath = '') {
-    const resolvedPath = String(installPath || '').trim();
-    if (!resolvedPath || !fs.existsSync(resolvedPath)) {
-      return [];
-    }
-
-    try {
-      const stat = fs.statSync(resolvedPath);
-      if (stat.isFile()) {
-        const fileName = path.basename(resolvedPath);
-        return [{ path: fileName, type: 'blob', name: fileName, size: stat.size }];
-      }
-
-      const tree = [];
-      this.scanLocalRepoTree(resolvedPath, resolvedPath, tree);
-      return tree;
-    } catch {
-      return [];
-    }
-  }
-
-  _isTextPreviewFile(filePath = '') {
-    const normalizedPath = normalizeRepoPath(filePath);
-    const baseName = path.posix.basename(normalizedPath);
-    const extension = path.posix.extname(baseName).toLowerCase();
-    if (TEXT_PREVIEW_EXTENSIONS.has(extension)) {
-      return true;
-    }
-    if (TEXT_PREVIEW_BASENAMES.has(baseName)) {
-      return true;
-    }
-    return /^\.env(\..+)?$/i.test(baseName);
-  }
-
-  _bufferLooksBinary(buffer) {
-    if (!Buffer.isBuffer(buffer)) return false;
-    const sampleLength = Math.min(buffer.length, 1024);
-    for (let index = 0; index < sampleLength; index += 1) {
-      if (buffer[index] === 0) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  async _resolvePluginFileSource(pluginInput = {}) {
-    const detail = await this.getPluginDetail(pluginInput);
-    if (!detail) {
-      throw new Error('插件不存在');
-    }
-
-    if (detail.installPath && fs.existsSync(detail.installPath)) {
-      const files = this._scanInstallPath(detail.installPath);
-      return {
-        detail,
-        installPath: detail.installPath,
-        managedPath: detail.managedPath || '',
-        repo: null,
-        fileContext: this._getScopedFileContext(files)
-      };
-    }
-
-    if (detail.managedPath && fs.existsSync(detail.managedPath)) {
-      const files = this._scanInstallPath(detail.managedPath);
-      return {
-        detail,
-        installPath: '',
-        managedPath: detail.managedPath,
-        repo: null,
-        fileContext: this._getScopedFileContext(files)
-      };
-    }
-
-    const repo = this.resolvePluginRepo(detail);
-    if (!repo) {
-      return {
-        detail,
-        installPath: '',
-        managedPath: detail.managedPath || '',
-        repo: null,
-        fileContext: this._getScopedFileContext([], detail.directory || '')
-      };
-    }
-
-    const repoTree = await this.fetchRepoTree(repo);
-    return {
-      detail,
-      installPath: '',
-      repo,
-      fileContext: this._getScopedFileContext(repoTree, detail.directory || '')
-    };
-  }
-
-  async getPluginFiles(pluginInput = {}) {
-    const source = await this._resolvePluginFileSource(pluginInput);
-    return {
-      files: source.fileContext.scopedFiles.map(file => {
-        const scopedPath = source.fileContext.toScopedPath(file.path);
-        return {
-          name: path.posix.basename(scopedPath),
-          path: scopedPath,
-          size: Number.isFinite(file.size) ? file.size : null,
-          isText: this._isTextPreviewFile(scopedPath)
-        };
-      })
-    };
-  }
-
-  async getPluginFileContent(pluginInput = {}, filePath = '') {
-    const normalizedPath = normalizeRepoPath(filePath);
-    if (!normalizedPath) {
-      throw new Error('请指定文件路径');
-    }
-
-    const source = await this._resolvePluginFileSource(pluginInput);
-    const targetFile = source.fileContext.scopedFiles.find(file =>
-      source.fileContext.toScopedPath(file.path) === normalizedPath
-    );
-
-    if (!targetFile) {
-      throw new Error(`文件 "${normalizedPath}" 不存在`);
-    }
-
-    const scopedPath = source.fileContext.toScopedPath(targetFile.path);
-    const declaredSize = Number.isFinite(targetFile.size) ? targetFile.size : null;
-
-    if (!this._isTextPreviewFile(scopedPath)) {
-      return {
-        path: scopedPath,
-        size: declaredSize,
-        content: '',
-        isBinary: true,
-        isBase64: false,
-        tooLarge: false
-      };
-    }
-
-    if (declaredSize && declaredSize > MAX_PLUGIN_FILE_PREVIEW_BYTES) {
-      return {
-        path: scopedPath,
-        size: declaredSize,
-        content: '',
-        isBinary: false,
-        isBase64: false,
-        tooLarge: true
-      };
-    }
-
-    let content = '';
-    let size = declaredSize;
-
-    if (source.installPath || source.managedPath) {
-      const fileRoot = source.installPath || source.managedPath;
-      const resolvedRoot = path.resolve(fileRoot);
-      const resolvedPath = path.resolve(fileRoot, targetFile.path);
-      if (resolvedPath !== resolvedRoot && !resolvedPath.startsWith(`${resolvedRoot}${path.sep}`)) {
-        throw new Error('文件路径无效');
-      }
-
-      const stats = fs.statSync(resolvedPath);
-      if (stats.size > MAX_PLUGIN_FILE_PREVIEW_BYTES) {
-        return {
-          path: scopedPath,
-          size: stats.size,
-          content: '',
-          isBinary: false,
-          isBase64: false,
-          tooLarge: true
-        };
-      }
-
-      const buffer = fs.readFileSync(resolvedPath);
-      if (this._bufferLooksBinary(buffer)) {
-        return {
-          path: scopedPath,
-          size: stats.size,
-          content: '',
-          isBinary: true,
-          isBase64: false,
-          tooLarge: false
-        };
-      }
-
-      content = buffer.toString('utf8');
-      size = stats.size;
-    } else if (source.repo) {
-      content = await this.fetchRepoFileContent(source.repo, targetFile.path, targetFile);
-      size = Buffer.byteLength(content, 'utf8');
-      if (size > MAX_PLUGIN_FILE_PREVIEW_BYTES) {
-        return {
-          path: scopedPath,
-          size,
-          content: '',
-          isBinary: false,
-          isBase64: false,
-          tooLarge: true
-        };
-      }
-    } else {
-      throw new Error('当前插件没有可读取的文件源');
-    }
-
-    return {
-      path: scopedPath,
-      size,
-      content,
-      isBinary: false,
-      isBase64: false,
-      tooLarge: false
-    };
-  }
-
-  _readPluginManifestFromInstallPath(installPath = '') {
-    const resolvedPath = String(installPath || '').trim();
-    if (!resolvedPath || !fs.existsSync(resolvedPath)) {
-      return null;
-    }
-
-    try {
-      const stat = fs.statSync(resolvedPath);
-      if (stat.isFile()) {
-        if (!resolvedPath.endsWith('.json')) {
-          return null;
-        }
-        return JSON.parse(stripJsonComments(fs.readFileSync(resolvedPath, 'utf8')));
-      }
-
-      const candidates = ['plugin.json', 'package.json'];
-      for (const candidate of candidates) {
-        const manifestPath = path.join(resolvedPath, candidate);
-        if (!fs.existsSync(manifestPath)) continue;
-        return JSON.parse(stripJsonComments(fs.readFileSync(manifestPath, 'utf8')));
-      }
-    } catch {
-      return null;
-    }
-
-    return null;
   }
 
   normalizeRepoConfig(repo = {}) {
@@ -969,10 +434,13 @@ class PluginsService {
   }
 
   _getOpenCodeConfigPath() {
-    if (fs.existsSync(OPENCODE_CONFIG_JSONC)) return OPENCODE_CONFIG_JSONC;
-    if (fs.existsSync(OPENCODE_CONFIG_JSON)) return OPENCODE_CONFIG_JSON;
-    if (fs.existsSync(OPENCODE_CONFIG_LEGACY)) return OPENCODE_CONFIG_LEGACY;
-    return OPENCODE_CONFIG_JSON;
+    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');
+    if (fs.existsSync(jsonc)) return jsonc;
+    if (fs.existsSync(json)) return json;
+    if (fs.existsSync(config)) return config;
+    return json;
   }
 
   _readOpenCodeConfig() {
@@ -1071,137 +539,12 @@ class PluginsService {
     return plugins;
   }
 
-  _normalizeManagedPluginStorageName(plugin = {}) {
-    const rawName = String(plugin.name || path.basename(plugin.installPath || plugin.directory || '') || '').trim();
-    if (!rawName) return '';
-    return rawName.replace(/[\\/]+/g, '__');
-  }
-
-  _getManagedPluginPath(plugin = {}) {
-    const storageName = this._normalizeManagedPluginStorageName(plugin);
-    return storageName ? path.join(this.storageDir, storageName) : '';
-  }
-
-  _ensureManagedPluginCopy(plugin = {}, options = {}) {
-    const overwrite = options.overwrite === true;
-    const sourcePath = String(plugin.installPath || '').trim();
-    if (!sourcePath || !fs.existsSync(sourcePath)) {
-      return false;
-    }
-
-    const managedPath = this._getManagedPluginPath(plugin);
-    if (!managedPath) {
-      return false;
-    }
-
-    if (fs.existsSync(managedPath)) {
-      if (!overwrite) {
-        return false;
-      }
-      fs.rmSync(managedPath, { recursive: true, force: true });
-    }
-
-    this._ensureDir(path.dirname(managedPath));
-    const stat = fs.statSync(sourcePath);
-    if (stat.isDirectory()) {
-      fs.mkdirSync(managedPath, { recursive: true });
-      this.copyDirRecursive(sourcePath, managedPath);
-      const repoSourceMeta = {
-        repoId: plugin.repoId || '',
-        repoProvider: plugin.repoProvider || '',
-        repoOwner: plugin.repoOwner || '',
-        repoName: plugin.repoName || '',
-        repoBranch: plugin.repoBranch || '',
-        repoDirectory: plugin.repoDirectory || plugin.directory || '',
-        repoHost: plugin.repoHost || '',
-        repoProjectPath: plugin.repoProjectPath || '',
-        repoLocalPath: plugin.repoLocalPath || '',
-        repoUrl: plugin.repoUrl || '',
-        source: plugin.source || ''
-      };
-      this.writeRepoSourceMeta(managedPath, repoSourceMeta);
-    } else {
-      fs.copyFileSync(sourcePath, managedPath);
-    }
-
-    return true;
-  }
-
-  _listManagedClaudePlugins() {
-    if (!fs.existsSync(this.storageDir)) return [];
-
-    const entries = fs.readdirSync(this.storageDir, { withFileTypes: true });
-    const plugins = [];
-
-    for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name.startsWith('.')) {
-        continue;
-      }
-
-      const managedPath = path.join(this.storageDir, entry.name);
-      const manifest = this._readPluginManifestFromInstallPath(managedPath) || {};
-      const repoSourceMeta = this.readRepoSourceMeta(managedPath) || {};
-      const pluginName = manifest.name || entry.name;
-
-      plugins.push({
-        name: pluginName,
-        version: manifest.version || '1.0.0',
-        description: manifest.description || '',
-        author: manifest.author || '',
-        directory: repoSourceMeta.repoDirectory || pluginName,
-        repoDirectory: repoSourceMeta.repoDirectory || '',
-        source: 'local-managed',
-        installPath: '',
-        managedPath,
-        installed: false,
-        enabled: true,
-        isLocal: true,
-        repoUrl: repoSourceMeta.repoUrl || '',
-        repoProvider: repoSourceMeta.repoProvider || '',
-        repoOwner: repoSourceMeta.repoOwner || '',
-        repoName: repoSourceMeta.repoName || '',
-        repoBranch: repoSourceMeta.repoBranch || 'main',
-        repoHost: repoSourceMeta.repoHost || '',
-        repoProjectPath: repoSourceMeta.repoProjectPath || '',
-        repoLocalPath: repoSourceMeta.repoLocalPath || '',
-        repoId: repoSourceMeta.repoId || ''
-      });
-    }
-
-    return plugins;
-  }
-
-  _mergeManagedClaudePlugins(plugins = [], options = {}) {
-    const syncManagedLocalPlugins = options.syncManagedLocalPlugins === true;
-
-    for (const installedPlugin of plugins) {
-      if (!installedPlugin.installPath || !fs.existsSync(installedPlugin.installPath)) {
-        continue;
-      }
-
-      this._ensureManagedPluginCopy(installedPlugin, {
-        overwrite: syncManagedLocalPlugins
-      });
-    }
-
-    const managedPlugins = this._listManagedClaudePlugins();
-    for (const managedPlugin of managedPlugins) {
-      const existing = plugins.find(plugin => plugin.name === managedPlugin.name || plugin.directory === managedPlugin.directory);
-      if (existing) {
-        existing.isLocal = true;
-        existing.managedPath = managedPlugin.managedPath;
-        continue;
-      }
-      plugins.push(managedPlugin);
-    }
-  }
-
   /**
    * List all installed plugins with their status
    * Reads from Claude Code's native installed_plugins.json
    * @returns {Object} { plugins: Array }
    */
-  listPlugins(options = {}) {
+  listPlugins() {
     if (this._isOpenCode()) {
       const plugins = [];
       const seen = new Set();
@@ -1232,7 +575,6 @@ class PluginsService {
     }
 
     const plugins = [];
-    const syncManagedLocalPlugins = options.syncManagedLocalPlugins === true;
 
     // Read Claude Code's installed_plugins.json
     if (fs.existsSync(CLAUDE_INSTALLED_FILE)) {
@@ -1302,7 +644,6 @@ class PluginsService {
                 marketplace,
                 version: install.version || '1.0.0',
                 installPath: install.installPath,
-                installed: true,
                 installedAt: install.installedAt,
                 scope: install.scope,
                 enabled: enabledState,
@@ -1340,8 +681,6 @@ class PluginsService {
       // Ignore legacy registry errors
     }
 
-    this._mergeManagedClaudePlugins(plugins, { syncManagedLocalPlugins });
-
     return { plugins };
   }
 
@@ -1380,183 +719,7 @@ class PluginsService {
       description: manifest?.description || '',
       author: manifest?.author || '',
       commands: manifest?.commands || [],
-      hooks: manifest?.hooks || manifest?.ctx?.hooks || [],
-      manifest
-    };
-  }
-
-  resolvePluginRepo(plugin = {}) {
-    let repo = null;
-
-    if (plugin.repoProvider || plugin.repoLocalPath || plugin.repoProjectPath || plugin.repoOwner) {
-      try {
-        repo = this.normalizeRepoConfig({
-          id: plugin.repoId,
-          provider: plugin.repoProvider,
-          host: plugin.repoHost,
-          owner: plugin.repoOwner,
-          name: plugin.repoName,
-          branch: plugin.repoBranch || 'main',
-          projectPath: plugin.repoProjectPath,
-          localPath: plugin.repoLocalPath,
-          repoUrl: plugin.repoUrl
-        });
-      } catch {
-        repo = null;
-      }
-    } else if (plugin.source) {
-      repo = this.parseRepoTreeSource(plugin.source);
-    }
-
-    if (!repo && plugin.repoUrl) {
-      const parsedTreeSource = this.parseRepoTreeSource(plugin.repoUrl);
-      if (parsedTreeSource) {
-        repo = parsedTreeSource;
-      } else if (plugin.repoUrl.includes('github.com')) {
-        const match = plugin.repoUrl.match(/github\.com\/([^\/]+)\/([^\/\.]+)/);
-        if (match) {
-          try {
-            repo = this.normalizeRepoConfig({
-              provider: 'github',
-              owner: match[1],
-              name: match[2],
-              branch: plugin.repoBranch || 'main'
-            });
-          } catch {
-            repo = null;
-          }
-        }
-      }
-    }
-
-    return repo;
-  }
-
-  async _readPluginManifestFromRepo(plugin = {}, repo = null) {
-    const resolvedRepo = repo || this.resolvePluginRepo(plugin);
-    if (!resolvedRepo) {
-      return null;
-    }
-
-    const normalizedDirectory = normalizeRepoPath(plugin.directory || '');
-    const candidates = [];
-
-    if (normalizedDirectory) {
-      if (/\.[a-z0-9]+$/i.test(path.posix.basename(normalizedDirectory))) {
-        candidates.push(normalizedDirectory);
-      } else {
-        candidates.push(`${normalizedDirectory}/plugin.json`, `${normalizedDirectory}/package.json`);
-      }
-    }
-
-    candidates.push('plugin.json', 'package.json');
-
-    for (const candidate of Array.from(new Set(candidates))) {
-      try {
-        return await this.fetchRepoJson(resolvedRepo, candidate);
-      } catch {
-        // try next candidate
-      }
-    }
-
-    return null;
-  }
-
-  async getPluginDetail(pluginInput = {}) {
-    const requestedPlugin = typeof pluginInput === 'string'
-      ? { name: pluginInput }
-      : { ...(pluginInput || {}) };
-    const requestedName = String(requestedPlugin.name || '').trim();
-
-    if (!requestedName && !requestedPlugin.directory) {
-      return null;
-    }
-
-    const installedPlugin = this.listPlugins().plugins.find(plugin => {
-      if (requestedName && (plugin.name === requestedName || plugin.directory === requestedName)) {
-        return true;
-      }
-      if (requestedPlugin.installPath && plugin.installPath === requestedPlugin.installPath) {
-        return true;
-      }
-      return Boolean(
-        requestedPlugin.repoId &&
-        plugin.repoId === requestedPlugin.repoId &&
-        plugin.directory === requestedPlugin.directory
-      );
-    }) || null;
-    const legacyPlugin = (!this._isOpenCode() && requestedName) ? getPlugin(requestedName) : null;
-
-    const mergedPlugin = {
-      ...requestedPlugin,
-      ...(installedPlugin || {}),
-      ...(legacyPlugin || {})
-    };
-    mergedPlugin.name = requestedName || mergedPlugin.name || mergedPlugin.directory || '';
-
-    if (!mergedPlugin.name) {
-      return null;
-    }
-
-    const fallbackInstallPath = (!mergedPlugin.installPath && !this._isOpenCode())
-      ? path.join(INSTALLED_DIR, mergedPlugin.name)
-      : '';
-    const installPath = mergedPlugin.installPath || (fallbackInstallPath && fs.existsSync(fallbackInstallPath) ? fallbackInstallPath : '');
-    const managedPath = mergedPlugin.managedPath && fs.existsSync(mergedPlugin.managedPath)
-      ? mergedPlugin.managedPath
-      : this._getManagedPluginPath(mergedPlugin);
-    const resolvedManagedPath = managedPath && fs.existsSync(managedPath) ? managedPath : '';
-
-    let manifest = this._readPluginManifestFromInstallPath(installPath);
-    if (!manifest && resolvedManagedPath) {
-      manifest = this._readPluginManifestFromInstallPath(resolvedManagedPath);
-    }
-    const repo = this.resolvePluginRepo(mergedPlugin);
-    if (!manifest) {
-      manifest = await this._readPluginManifestFromRepo(mergedPlugin, repo);
-    }
-
-    let fileSummary = this._createEmptyContentSummary();
-    if (installPath && fs.existsSync(installPath)) {
-      fileSummary = this._summarizeContentFromFiles(this._scanInstallPath(installPath));
-    } else if (resolvedManagedPath) {
-      fileSummary = this._summarizeContentFromFiles(this._scanInstallPath(resolvedManagedPath));
-    } else if (repo) {
-      try {
-        const repoTree = await this.fetchRepoTree(repo);
-        fileSummary = this._summarizeContentFromFiles(repoTree, mergedPlugin.directory || '');
-      } catch {
-        fileSummary = this._createEmptyContentSummary();
-      }
-    }
-
-    const manifestSummary = this._summarizeManifestContent(manifest);
-    const contentSummary = this._mergeContentSummary(manifestSummary, fileSummary);
-    const commands = mergeContentCollections(
-      contentSummary.commands,
-      normalizeContentCollection(mergedPlugin.commands)
-    );
-    const hooks = mergeContentCollections(
-      contentSummary.hooks,
-      normalizeContentCollection(mergedPlugin.hooks)
-    );
-    const installed = mergedPlugin.installed !== undefined
-      ? !!mergedPlugin.installed
-      : Boolean(mergedPlugin.isInstalled || installPath || installedPlugin);
-
-    return {
-      ...mergedPlugin,
-      installPath,
-      managedPath: resolvedManagedPath,
-      installed,
-      description: mergedPlugin.description || manifest?.description || '',
-      author: mergedPlugin.author || manifest?.author || '',
-      version: mergedPlugin.version || manifest?.version || (this._isOpenCode() ? 'latest' : '1.0.0'),
-      commands,
-      hooks,
-      skills: contentSummary.skills,
-      agents: contentSummary.agents,
-      contentSummary,
+      hooks: manifest?.hooks || [],
       manifest
     };
   }
@@ -1610,124 +773,6 @@ class PluginsService {
     return await installPluginCore(source);
   }
 
-  installLocalPlugin(name) {
-    const plugin = this.listPlugins().plugins.find(item => item.name === name || item.directory === name);
-    const managedPath = plugin?.managedPath || '';
-
-    if (!managedPath || !fs.existsSync(managedPath)) {
-      throw new Error(`本地插件 "${name}" 不存在`);
-    }
-
-    if (this._isOpenCode()) {
-      const pluginsDir = this._getOpenCodePluginsDir();
-      this._ensureDir(pluginsDir);
-      const targetPath = path.join(pluginsDir, path.basename(managedPath));
-
-      if (fs.existsSync(targetPath)) {
-        return { success: true, plugin: { name: plugin.name }, message: 'Already installed' };
-      }
-
-      const stat = fs.statSync(managedPath);
-      if (stat.isDirectory()) {
-        fs.mkdirSync(targetPath, { recursive: true });
-        this.copyDirRecursive(managedPath, targetPath);
-      } else {
-        fs.copyFileSync(managedPath, targetPath);
-      }
-
-      return {
-        success: true,
-        plugin: { name: plugin.name, version: plugin.version || '1.0.0', description: plugin.description || '' },
-        message: 'Installed successfully'
-      };
-    }
-
-    const manifest = this._readPluginManifestFromInstallPath(managedPath) || {};
-    const pluginName = manifest.name || plugin?.name || name;
-    const pluginDir = path.join(INSTALLED_DIR, pluginName);
-
-    if (fs.existsSync(pluginDir)) {
-      return { success: true, plugin: { name: pluginName }, message: 'Already installed' };
-    }
-
-    fs.mkdirSync(pluginDir, { recursive: true });
-    this.copyDirRecursive(managedPath, pluginDir);
-
-    const installTimestamp = new Date().toISOString();
-    const repoSourceMeta = this.readRepoSourceMeta(managedPath) || {};
-    const sourceUrl = plugin?.source || repoSourceMeta.source || plugin?.repoUrl || '';
-
-    try {
-      const { addPlugin } = require('../../plugins/registry');
-      addPlugin(pluginName, {
-        version: manifest.version || plugin?.version || '1.0.0',
-        enabled: true,
-        installedAt: installTimestamp,
-        source: sourceUrl
-      });
-    } catch (e) {
-      console.warn('[PluginsService] Legacy registry addPlugin warning:', e.message);
-    }
-
-    this.writeRepoSourceMeta(pluginDir, {
-      repoId: plugin?.repoId || repoSourceMeta.repoId || '',
-      repoProvider: plugin?.repoProvider || repoSourceMeta.repoProvider || '',
-      repoOwner: plugin?.repoOwner || repoSourceMeta.repoOwner || '',
-      repoName: plugin?.repoName || repoSourceMeta.repoName || '',
-      repoBranch: plugin?.repoBranch || repoSourceMeta.repoBranch || 'main',
-      repoDirectory: plugin?.repoDirectory || repoSourceMeta.repoDirectory || plugin?.directory || '',
-      repoHost: plugin?.repoHost || repoSourceMeta.repoHost || '',
-      repoProjectPath: plugin?.repoProjectPath || repoSourceMeta.repoProjectPath || '',
-      repoLocalPath: plugin?.repoLocalPath || repoSourceMeta.repoLocalPath || '',
-      repoUrl: plugin?.repoUrl || repoSourceMeta.repoUrl || '',
-      source: sourceUrl
-    });
-
-    try {
-      this._ensureDir(CLAUDE_PLUGINS_DIR);
-      let nativeData = { plugins: {} };
-      if (fs.existsSync(CLAUDE_INSTALLED_FILE)) {
-        try {
-          nativeData = JSON.parse(fs.readFileSync(CLAUDE_INSTALLED_FILE, 'utf8'));
-          if (!nativeData.plugins) nativeData.plugins = {};
-        } catch {
-          nativeData = { plugins: {} };
-        }
-      }
-
-      nativeData.plugins[`${pluginName}@ctx`] = [{
-        version: manifest.version || plugin?.version || '1.0.0',
-        installPath: pluginDir,
-        installedAt: installTimestamp,
-        scope: 'user',
-        source: sourceUrl,
-        repoId: plugin?.repoId || repoSourceMeta.repoId || '',
-        repoProvider: plugin?.repoProvider || repoSourceMeta.repoProvider || '',
-        repoOwner: plugin?.repoOwner || repoSourceMeta.repoOwner || '',
-        repoName: plugin?.repoName || repoSourceMeta.repoName || '',
-        repoBranch: plugin?.repoBranch || repoSourceMeta.repoBranch || 'main',
-        repoDirectory: plugin?.repoDirectory || repoSourceMeta.repoDirectory || plugin?.directory || '',
-        repoHost: plugin?.repoHost || repoSourceMeta.repoHost || '',
-        repoProjectPath: plugin?.repoProjectPath || repoSourceMeta.repoProjectPath || '',
-        repoLocalPath: plugin?.repoLocalPath || repoSourceMeta.repoLocalPath || '',
-        repoUrl: plugin?.repoUrl || repoSourceMeta.repoUrl || ''
-      }];
-      fs.writeFileSync(CLAUDE_INSTALLED_FILE, JSON.stringify(nativeData, null, 2), 'utf8');
-    } catch (e) {
-      console.error('[PluginsService] Failed to update native installed_plugins.json:', e.message);
-    }
-
-    return {
-      success: true,
-      plugin: {
-        name: pluginName,
-        version: manifest.version || plugin?.version || '1.0.0',
-        description: manifest.description || plugin?.description || ''
-      },
-      message: 'Installed successfully'
-    };
-  }
-
   /**
    * Install plugin from repo directory
    * @private
@@ -2115,8 +1160,9 @@ class PluginsService {
    */
   updatePluginConfig(name, config) {
     if (this._isOpenCode()) {
-      this._ensureDir(OPENCODE_PLUGINS_CONFIG_DIR);
-      const configFile = path.join(OPENCODE_PLUGINS_CONFIG_DIR, `${name}.json`);
+      const configDir = path.join(OPENCODE_CONFIG_DIR, 'plugins-config');
+      this._ensureDir(configDir);
+      const configFile = path.join(configDir, `${name}.json`);
       fs.writeFileSync(configFile, JSON.stringify(config, null, 2), 'utf8');
       return {
         success: true,
@@ -2606,8 +1652,7 @@ class PluginsService {
         tree.push({ path: relativePath, type: 'tree', name: entry.name });
         this.scanLocalRepoTree(fullPath, repoRoot, tree);
       } else {
-        const stats = fs.statSync(fullPath);
-        tree.push({ path: relativePath, type: 'blob', name: entry.name, size: stats.size });
+        tree.push({ path: relativePath, type: 'blob', name: entry.name });
       }
     }
   }
@@ -2847,7 +1892,44 @@ class PluginsService {
         }
       }
 
-      const repo = this.resolvePluginRepo(plugin);
+      let repo = null;
+      if (plugin.repoProvider || plugin.repoLocalPath || plugin.repoProjectPath || plugin.repoOwner) {
+        try {
+          repo = this.normalizeRepoConfig({
+            id: plugin.repoId,
+            provider: plugin.repoProvider,
+            host: plugin.repoHost,
+            owner: plugin.repoOwner,
+            name: plugin.repoName,
+            branch: plugin.repoBranch || 'main',
+            projectPath: plugin.repoProjectPath,
+            localPath: plugin.repoLocalPath,
+            repoUrl: plugin.repoUrl
+          });
+        } catch {
+          repo = null;
+        }
+      } else if (plugin.source) {
+        repo = this.parseRepoTreeSource(plugin.source);
+      }
+
+      if (!repo && plugin.repoUrl) {
+        const parsedTreeSource = this.parseRepoTreeSource(plugin.repoUrl);
+        if (parsedTreeSource) {
+          repo = parsedTreeSource;
+        } else if (plugin.repoUrl.includes('github.com')) {
+          const match = plugin.repoUrl.match(/github\.com\/([^\/]+)\/([^\/\.]+)/);
+          if (match) {
+            repo = this.normalizeRepoConfig({
+              provider: 'github',
+              owner: match[1],
+              name: match[2],
+              branch: plugin.repoBranch || 'main'
+            });
+          }
+        }
+      }
+
       if (!repo) return '';
 
       for (const candidate of readmeCandidates) {
@@ -2898,7 +1980,6 @@ class PluginsService {
       lspServers: data.lspServers || null,
       commands: data.commands || [],
       hooks: data.hooks || [],
-      contentSummary: data.contentSummary || this._createEmptyContentSummary(),
       isInstalled: false
     };
   }
@@ -2938,11 +2019,7 @@ class PluginsService {
           directory: file.path,
           installSource: githubRepo ? '' : installSource,
           marketplaceFormat: 'opencode-plugin-json',
-          repoUrl,
-          contentSummary: this._mergeContentSummary(
-            this._summarizeManifestContent(manifest),
-            this._summarizeContentFromFiles(tree, file.path)
-          )
+          repoUrl
         });
       })
     );
@@ -3009,11 +2086,7 @@ class PluginsService {
                 version: plugin.version || '1.0.0',
                 category: plugin.category || 'general',
                 directory: plugin.source?.replace(/^\.\//, '') || plugin.name,
-                lspServers: plugin.lspServers || null,
-                contentSummary: this._summarizeContentFromFiles(
-                  files,
-                  plugin.source?.replace(/^\.\//, '') || plugin.name
-                )
+                lspServers: plugin.lspServers || null
               }));
             }
             continue; // Skip legacy format check
@@ -3039,8 +2112,6 @@ class PluginsService {
         for (const dir of pluginDirs) {
           try {
             const manifest = await readJson(`${dir}/plugin.json`);
-            const manifestSummary = this._summarizeManifestContent(manifest);
-            const fileSummary = this._summarizeContentFromFiles(files, dir);
 
             marketPlugins.push(this.buildMarketPluginItem(repo, {
               name: manifest.name || dir,
@@ -3048,9 +2119,8 @@ class PluginsService {
               author: manifest.author || repo.owner,
               version: manifest.version || '1.0.0',
               directory: dir,
-              commands: manifestSummary.commands,
-              hooks: manifestSummary.hooks,
-              contentSummary: this._mergeContentSummary(manifestSummary, fileSummary)
+              commands: manifest.commands || [],
+              hooks: manifest.hooks || []
             }));
           } catch (e) {
             // OpenCode 仓库常见 package.json 格式
@@ -3062,11 +2132,7 @@ class PluginsService {
                   description: pkg.description || '',
                   author: pkg.author || repo.owner,
                   version: pkg.version || '1.0.0',
-                  directory: dir,
-                  contentSummary: this._mergeContentSummary(
-                    this._summarizeManifestContent(pkg),
-                    this._summarizeContentFromFiles(files, dir)
-                  )
+                  directory: dir
                 }));
               } catch (pkgErr) {
                 // neither plugin.json nor package.json