coding-tool-x 3.5.6 → 3.5.8

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

@@ -18,10 +18,15 @@ const { INSTALLED_DIR, CONFIG_DIR } = require('../../plugins/constants');
 const { NATIVE_PATHS, PATHS } = require('../../config/paths');
 const { maskToken } = require('./oauth-utils');
 
-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 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 REPO_SOURCE_META_FILE = '.cc-tool-plugin-source.json';
 const SUPPORTED_REPO_PROVIDERS = ['github', 'gitlab', 'local'];
 const DEFAULT_GITHUB_HOST = 'https://github.com';
@@ -30,6 +35,15 @@ 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 }));
@@ -330,12 +344,16 @@ class PluginsService {
     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.opencodePluginsDir = path.join(OPENCODE_CONFIG_DIR, 'plugins');
-    this.opencodeLegacyPluginsDir = path.join(OPENCODE_CONFIG_DIR, 'plugin');
+    this.storageDir = this.platform === 'opencode'
+      ? PATHS.localPlugins.opencode
+      : PATHS.localPlugins.claude;
+    this.opencodePluginsDir = OPENCODE_PLUGINS_DIR;
+    this.opencodeLegacyPluginsDir = OPENCODE_LEGACY_PLUGINS_DIR;
     this.marketCachePath = this.platform === 'opencode'
       ? PATHS.pluginMarketCache.opencode
       : PATHS.pluginMarketCache.claude;
     this._marketCache = null;
+    this._ensureDir(this.storageDir);
   }
 
   _createEmptyContentSummary() {
@@ -391,8 +409,7 @@ class PluginsService {
     };
   }
 
-  _summarizeContentFromFiles(files = [], directory = '') {
-    const emptySummary = this._createEmptyContentSummary();
+  _getScopedFileContext(files = [], directory = '') {
     const normalizedDirectory = normalizeRepoPath(directory);
     const directoryLooksLikeFile = /\.[a-z0-9]+$/i.test(path.posix.basename(normalizedDirectory || ''));
     const allFiles = (Array.isArray(files) ? files : [])
@@ -414,12 +431,26 @@ class PluginsService {
     }
 
     const toScopedPath = (filePath = '') => {
+      const normalizedFilePath = normalizeRepoPath(filePath);
       if (!normalizedDirectory || directoryLooksLikeFile) {
-        return normalizeRepoPath(filePath);
+        return normalizedFilePath;
       }
       const prefix = `${normalizedDirectory}/`;
-      return filePath.startsWith(prefix) ? filePath.slice(prefix.length) : filePath;
+      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 = [];
@@ -495,7 +526,7 @@ class PluginsService {
       const stat = fs.statSync(resolvedPath);
       if (stat.isFile()) {
         const fileName = path.basename(resolvedPath);
-        return [{ path: fileName, type: 'blob', name: fileName }];
+        return [{ path: fileName, type: 'blob', name: fileName, size: stat.size }];
       }
 
       const tree = [];
@@ -506,6 +537,197 @@ class PluginsService {
     }
   }
 
+  _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)) {
@@ -747,13 +969,10 @@ 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');
-    if (fs.existsSync(jsonc)) return jsonc;
-    if (fs.existsSync(json)) return json;
-    if (fs.existsSync(config)) return config;
-    return json;
+    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;
   }
 
   _readOpenCodeConfig() {
@@ -852,12 +1071,137 @@ 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() {
+  listPlugins(options = {}) {
     if (this._isOpenCode()) {
       const plugins = [];
       const seen = new Set();
@@ -888,6 +1232,7 @@ class PluginsService {
     }
 
     const plugins = [];
+    const syncManagedLocalPlugins = options.syncManagedLocalPlugins === true;
 
     // Read Claude Code's installed_plugins.json
     if (fs.existsSync(CLAUDE_INSTALLED_FILE)) {
@@ -957,6 +1302,7 @@ class PluginsService {
                 marketplace,
                 version: install.version || '1.0.0',
                 installPath: install.installPath,
+                installed: true,
                 installedAt: install.installedAt,
                 scope: install.scope,
                 enabled: enabledState,
@@ -994,6 +1340,8 @@ class PluginsService {
       // Ignore legacy registry errors
     }
 
+    this._mergeManagedClaudePlugins(plugins, { syncManagedLocalPlugins });
+
     return { plugins };
   }
 
@@ -1154,8 +1502,15 @@ class PluginsService {
       ? 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);
@@ -1164,6 +1519,8 @@ class PluginsService {
     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);
@@ -1190,6 +1547,7 @@ class PluginsService {
     return {
       ...mergedPlugin,
       installPath,
+      managedPath: resolvedManagedPath,
       installed,
       description: mergedPlugin.description || manifest?.description || '',
       author: mergedPlugin.author || manifest?.author || '',
@@ -1252,6 +1610,124 @@ 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
@@ -1639,9 +2115,8 @@ class PluginsService {
    */
   updatePluginConfig(name, config) {
     if (this._isOpenCode()) {
-      const configDir = path.join(OPENCODE_CONFIG_DIR, 'plugins-config');
-      this._ensureDir(configDir);
-      const configFile = path.join(configDir, `${name}.json`);
+      this._ensureDir(OPENCODE_PLUGINS_CONFIG_DIR);
+      const configFile = path.join(OPENCODE_PLUGINS_CONFIG_DIR, `${name}.json`);
       fs.writeFileSync(configFile, JSON.stringify(config, null, 2), 'utf8');
       return {
         success: true,
@@ -2131,7 +2606,8 @@ class PluginsService {
         tree.push({ path: relativePath, type: 'tree', name: entry.name });
         this.scanLocalRepoTree(fullPath, repoRoot, tree);
       } else {
-        tree.push({ path: relativePath, type: 'blob', name: entry.name });
+        const stats = fs.statSync(fullPath);
+        tree.push({ path: relativePath, type: 'blob', name: entry.name, size: stats.size });
       }
     }
   }

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

@@ -6,20 +6,16 @@
 
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
-const { NATIVE_PATHS, PATHS } = require('../../config/paths');
-const { resolvePreferredHomeDir } = require('../../utils/home-dir');
-
-const HOME_DIR = resolvePreferredHomeDir(process.platform, process.env, os.homedir());
+const { PATHS, getNativePlatformPromptPath } = require('../../config/paths');
 
 // Prompts 配置文件路径
 const PROMPTS_FILE = PATHS.prompts;
 
 // 各平台提示词文件路径
-const CLAUDE_PROMPT_PATH = path.join(HOME_DIR, '.claude', 'CLAUDE.md');
-const CODEX_PROMPT_PATH = path.join(HOME_DIR, '.codex', 'AGENTS.md');
-const GEMINI_PROMPT_PATH = path.join(HOME_DIR, '.gemini', 'GEMINI.md');
-const OPENCODE_PROMPT_PATH = path.join(NATIVE_PATHS.opencode.config, 'AGENTS.md');
+const CLAUDE_PROMPT_PATH = getNativePlatformPromptPath('claude');
+const CODEX_PROMPT_PATH = getNativePlatformPromptPath('codex');
+const GEMINI_PROMPT_PATH = getNativePlatformPromptPath('gemini');
+const OPENCODE_PROMPT_PATH = getNativePlatformPromptPath('opencode');
 
 function normalizeApps(apps = {}, defaults = { claude: true, codex: true, gemini: true, opencode: false }) {
   return {

package/src/server/services/sessions.js

@@ -14,8 +14,8 @@ const { globalCache, CacheKeys } = require('./enhanced-cache');
 const { PATHS, NATIVE_PATHS } = require('../../config/paths');
 
 const CLAUDE_PROJECTS_DIR = NATIVE_PATHS.claude.projects;
-const CODEX_PROJECTS_DIR = path.join(path.dirname(NATIVE_PATHS.codex.config), 'projects');
-const GEMINI_PROJECTS_DIR = path.join(path.dirname(NATIVE_PATHS.gemini.env), 'projects');
+const CODEX_PROJECTS_DIR = NATIVE_PATHS.codex.projects;
+const GEMINI_PROJECTS_DIR = NATIVE_PATHS.gemini.projects;
 const PROJECT_PATH_CACHE_TTL_MS = 5 * 60 * 1000;
 const MAX_PROJECT_PATH_CACHE_ENTRIES = 500;
 let projectPathResolutionCache = new Map();