coding-tool-x 3.4.4 → 3.4.6

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

@@ -5,17 +5,27 @@
  */
 
 const fs = require('fs');
+const os = require('os');
+const http = require('http');
+const https = require('https');
 const path = require('path');
+const { execFileSync } = require('child_process');
+const AdmZip = require('adm-zip');
 const { listPlugins, getPlugin, updatePlugin: updatePluginRegistry } = require('../../plugins/registry');
 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 { 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 REPO_SOURCE_META_FILE = '.cc-tool-plugin-source.json';
+const SUPPORTED_REPO_PROVIDERS = ['github', 'gitlab', 'local'];
+const DEFAULT_GITHUB_HOST = 'https://github.com';
+const DEFAULT_GITLAB_HOST = 'https://gitlab.com';
 const DEFAULT_REPOS_BY_PLATFORM = {
   claude: [],
   opencode: []
@@ -25,6 +35,126 @@ function cloneRepos(repos = []) {
   return repos.map(repo => ({ ...repo }));
 }
 
+function normalizeRepoToken(token = '') {
+  return String(token || '').trim();
+}
+
+function normalizeRepoPath(input = '') {
+  return String(input || '')
+    .replace(/\\/g, '/')
+    .replace(/^\/+/, '')
+    .replace(/\/+$/, '');
+}
+
+function normalizeRepoDirectory(directory = '') {
+  return normalizeRepoPath(directory);
+}
+
+function stripGitSuffix(value = '') {
+  return String(value || '').replace(/\.git$/i, '');
+}
+
+function isWindowsAbsolutePath(input = '') {
+  return /^[a-zA-Z]:[\\/]/.test(String(input || ''));
+}
+
+function expandHomePath(input = '') {
+  const normalized = String(input || '').trim();
+  if (!normalized) return '';
+  if (normalized.startsWith('~/')) {
+    return path.join(process.env.HOME || process.env.USERPROFILE || os.homedir(), normalized.slice(2));
+  }
+  if (normalized === '~') {
+    return process.env.HOME || process.env.USERPROFILE || os.homedir();
+  }
+  if (normalized.startsWith('file://')) {
+    try {
+      return decodeURIComponent(new URL(normalized).pathname);
+    } catch {
+      return normalized;
+    }
+  }
+  return normalized;
+}
+
+function resolveLocalRepoPath(input = '') {
+  const expanded = expandHomePath(input);
+  if (!expanded) return '';
+  return path.resolve(expanded);
+}
+
+function normalizeRepoHost(host, provider = 'github') {
+  const fallback = provider === 'gitlab' ? DEFAULT_GITLAB_HOST : DEFAULT_GITHUB_HOST;
+  let normalized = String(host || '').trim();
+  if (!normalized) {
+    normalized = fallback;
+  }
+  if (!/^https?:\/\//i.test(normalized)) {
+    normalized = `https://${normalized}`;
+  }
+  try {
+    const parsed = new URL(normalized);
+    return `${parsed.protocol}//${parsed.host}`;
+  } catch {
+    return fallback;
+  }
+}
+
+function extractHostname(host = '') {
+  const normalized = String(host || '').trim();
+  if (!normalized) return '';
+  try {
+    return new URL(normalized).hostname || '';
+  } catch {
+    return normalized.replace(/^https?:\/\//i, '').replace(/\/.*$/, '');
+  }
+}
+
+function buildRepoUrl(repo) {
+  if (repo.provider === 'local') {
+    return repo.localPath || '';
+  }
+  if (repo.provider === 'gitlab') {
+    return `${repo.host}/${repo.projectPath}`;
+  }
+  return `${repo.host}/${repo.owner}/${repo.name}`;
+}
+
+function buildRepoLabel(repo) {
+  if (repo.provider === 'local') {
+    return repo.localPath || '';
+  }
+  if (repo.provider === 'gitlab') {
+    return repo.projectPath || '';
+  }
+  return [repo.owner, repo.name].filter(Boolean).join('/');
+}
+
+function buildRepoId(repo) {
+  const branch = String(repo.branch || 'main').trim() || 'main';
+  const directory = normalizeRepoDirectory(repo.directory);
+  if (repo.provider === 'local') {
+    return `local:${repo.localPath}::${directory}`;
+  }
+  if (repo.provider === 'gitlab') {
+    return `gitlab:${repo.host}::${repo.projectPath}::${branch}::${directory}`;
+  }
+  return `github:${repo.host}::${repo.owner}/${repo.name}::${branch}::${directory}`;
+}
+
+function isLikelyLocalPath(input = '') {
+  const normalized = String(input || '').trim();
+  if (!normalized) return false;
+  return (
+    normalized.startsWith('/') ||
+    normalized.startsWith('~/') ||
+    normalized.startsWith('./') ||
+    normalized.startsWith('../') ||
+    normalized.startsWith('file://') ||
+    isWindowsAbsolutePath(normalized)
+  );
+}
+
 function stripJsonComments(input = '') {
   let result = '';
   let inString = false;
@@ -81,6 +211,7 @@ function stripJsonComments(input = '') {
 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.opencodePluginsDir = path.join(OPENCODE_CONFIG_DIR, 'plugins');
     this.opencodeLegacyPluginsDir = path.join(OPENCODE_CONFIG_DIR, 'plugin');
@@ -90,6 +221,133 @@ class PluginsService {
     this._marketCache = null;
   }
 
+  normalizeRepoConfig(repo = {}) {
+    const provider = SUPPORTED_REPO_PROVIDERS.includes(repo.provider)
+      ? repo.provider
+      : (repo.localPath || isLikelyLocalPath(repo.url || '') ? 'local' : (repo.projectPath ? 'gitlab' : 'github'));
+    const rawRepoUrl = String(repo.repoUrl || repo.url || '').trim();
+    let parsedOwner = String(repo.owner || '').trim();
+    let parsedName = stripGitSuffix(repo.name || '');
+    let parsedProjectPath = normalizeRepoPath(repo.projectPath || '');
+
+    if (rawRepoUrl && !parsedProjectPath) {
+      try {
+        const parsedUrl = new URL(rawRepoUrl);
+        const pathParts = parsedUrl.pathname.replace(/^\/+|\/+$/g, '').replace(/\.git$/i, '').split('/').filter(Boolean);
+        if (provider === 'gitlab' && pathParts.length > 0) {
+          parsedProjectPath = pathParts.join('/');
+        } else if (pathParts.length >= 2) {
+          parsedOwner = parsedOwner || pathParts[0];
+          parsedName = parsedName || stripGitSuffix(pathParts[1]);
+        }
+      } catch {
+        // ignore invalid url, validation below will surface missing fields
+      }
+    }
+
+    const normalized = {
+      provider,
+      branch: String(repo.branch || 'main').trim() || 'main',
+      directory: normalizeRepoDirectory(repo.directory),
+      enabled: repo.enabled !== false
+    };
+
+    if (provider === 'local') {
+      normalized.localPath = resolveLocalRepoPath(repo.localPath || repo.path || repo.url || '');
+      if (!normalized.localPath) {
+        throw new Error('Missing local repository path');
+      }
+      normalized.name = path.basename(normalized.localPath) || 'local-repo';
+    } else if (provider === 'gitlab') {
+      normalized.host = normalizeRepoHost(repo.host, 'gitlab');
+      normalized.projectPath = normalizeRepoPath(parsedProjectPath || [parsedOwner, parsedName].filter(Boolean).join('/'));
+      if (!normalized.projectPath) {
+        throw new Error('Missing GitLab project path');
+      }
+      normalized.name = stripGitSuffix(normalized.projectPath.split('/').pop() || '');
+      normalized.owner = normalized.projectPath.split('/')[0] || '';
+    } else {
+      normalized.host = normalizeRepoHost(repo.host, 'github');
+      normalized.owner = parsedOwner;
+      normalized.name = parsedName;
+      if (!normalized.owner || !normalized.name) {
+        throw new Error('Repository owner and name are required');
+      }
+    }
+
+    normalized.repoUrl = repo.repoUrl || repo.url || buildRepoUrl(normalized);
+    normalized.url = normalized.repoUrl;
+    normalized.label = buildRepoLabel(normalized);
+    normalized.id = buildRepoId(normalized);
+
+    if (provider !== 'local') {
+      const token = normalizeRepoToken(repo.token);
+      if (token) {
+        normalized.token = token;
+      }
+    }
+
+    if (repo.source) normalized.source = repo.source;
+    if (repo.marketplace) normalized.marketplace = repo.marketplace;
+    if (repo.lastUpdated) normalized.lastUpdated = repo.lastUpdated;
+    if (repo.addedAt) normalized.addedAt = repo.addedAt;
+
+    return normalized;
+  }
+
+  normalizeRepos(repos = []) {
+    return repos.map(repo => this.normalizeRepoConfig(repo));
+  }
+
+  toClientRepo(repo = {}) {
+    const normalizedRepo = this.normalizeRepoConfig(repo);
+    const token = normalizeRepoToken(normalizedRepo.token);
+    const clientRepo = {
+      ...normalizedRepo,
+      hasToken: Boolean(token),
+      tokenPreview: token ? maskToken(token) : ''
+    };
+    delete clientRepo.token;
+    return clientRepo;
+  }
+
+  getReposForClient(repos = null) {
+    const sourceRepos = Array.isArray(repos) ? repos : this.getRepos();
+    return sourceRepos.map(repo => this.toClientRepo(repo));
+  }
+
+  findStoredRepo(repo = {}) {
+    const repoId = String(repo.id || repo.repoId || '').trim();
+    const repos = this.loadReposConfig().repos;
+
+    if (repoId) {
+      return repos.find(candidate => candidate.id === repoId) || null;
+    }
+
+    try {
+      const normalizedRepo = this.normalizeRepoConfig(repo);
+      return repos.find(candidate => candidate.id === normalizedRepo.id) || null;
+    } catch {
+      return null;
+    }
+  }
+
+  resolveRepoToken(repo = null) {
+    if (!repo || typeof repo !== 'object') return null;
+
+    const directToken = normalizeRepoToken(repo.token);
+    if (directToken) {
+      return directToken;
+    }
+
+    const storedRepo = this.findStoredRepo(repo);
+    if (!storedRepo) {
+      return null;
+    }
+
+    return normalizeRepoToken(storedRepo.token) || null;
+  }
+
   clearMarketCache({ removeFile = true } = {}) {
     this._marketCache = null;
     if (removeFile) {
@@ -138,8 +396,12 @@ class PluginsService {
     for (const plugin of preparedPlugins) {
       const key = [
         plugin.name || '',
+        plugin.repoId || '',
+        plugin.repoProvider || '',
         plugin.repoOwner || '',
         plugin.repoName || '',
+        plugin.repoProjectPath || '',
+        plugin.repoLocalPath || '',
         plugin.directory || plugin.installSource || ''
       ].join('::');
       if (seen.has(key)) continue;
@@ -229,6 +491,7 @@ class PluginsService {
 
       if (entry.isDirectory()) {
         const pkgPath = path.join(fullPath, 'package.json');
+        const repoSourceMeta = this.readRepoSourceMeta(fullPath) || {};
         let packageName = entry.name;
         let description = '';
         let version = '1.0.0';
@@ -251,7 +514,8 @@ class PluginsService {
           description,
           installed: true,
           enabled: true,
-          pluginType: 'local'
+          pluginType: 'local',
+          ...repoSourceMeta
         });
         continue;
       }
@@ -325,7 +589,16 @@ class PluginsService {
               // Read plugin.json from installPath for description
               let description = '';
               let source = install.source || '';
-              let repoUrl = '';
+              let repoUrl = install.repoUrl || '';
+              let repoProvider = install.repoProvider || '';
+              let repoOwner = install.repoOwner || '';
+              let repoName = install.repoName || '';
+              let repoBranch = install.repoBranch || 'main';
+              let repoDirectory = install.repoDirectory || '';
+              let repoHost = install.repoHost || '';
+              let repoProjectPath = install.repoProjectPath || '';
+              let repoLocalPath = install.repoLocalPath || '';
+              let repoId = install.repoId || '';
 
               if (install.installPath && fs.existsSync(install.installPath)) {
                 const manifestPath = path.join(install.installPath, 'plugin.json');
@@ -337,13 +610,28 @@ class PluginsService {
                     // Ignore parse errors
                   }
                 }
+
+                const repoSourceMeta = this.readRepoSourceMeta(install.installPath) || {};
+                repoUrl = repoUrl || repoSourceMeta.repoUrl || '';
+                repoProvider = repoProvider || repoSourceMeta.repoProvider || '';
+                repoOwner = repoOwner || repoSourceMeta.repoOwner || '';
+                repoName = repoName || repoSourceMeta.repoName || '';
+                repoBranch = repoBranch || repoSourceMeta.repoBranch || 'main';
+                repoDirectory = repoDirectory || repoSourceMeta.repoDirectory || '';
+                repoHost = repoHost || repoSourceMeta.repoHost || '';
+                repoProjectPath = repoProjectPath || repoSourceMeta.repoProjectPath || '';
+                repoLocalPath = repoLocalPath || repoSourceMeta.repoLocalPath || '';
+                repoId = repoId || repoSourceMeta.repoId || '';
               }
 
               // Parse repoUrl from source if available
-              if (source) {
+              if (!repoUrl && source) {
                 const match = source.match(/github\.com\/([^\/]+)\/([^\/\.]+)/);
                 if (match) {
                   repoUrl = `https://github.com/${match[1]}/${match[2]}`;
+                  repoProvider = repoProvider || 'github';
+                  repoOwner = repoOwner || match[1];
+                  repoName = repoName || match[2];
                 }
               }
 
@@ -361,7 +649,17 @@ class PluginsService {
                 enabled: enabledState,
                 description,
                 source,
-                repoUrl
+                repoUrl,
+                repoProvider,
+                repoOwner,
+                repoName,
+                repoBranch,
+                directory: repoDirectory || install.installPath || '',
+                repoDirectory,
+                repoHost,
+                repoProjectPath,
+                repoLocalPath,
+                repoId
               });
             }
           }
@@ -434,14 +732,13 @@ class PluginsService {
    */
   async installPlugin(source, repoInfo = null) {
     if (this._isOpenCode()) {
-      if (repoInfo && repoInfo.owner && repoInfo.name && repoInfo.directory) {
-        return this._installFromGitHubDirectory(repoInfo, { installRoot: this._getOpenCodePluginsDir() });
+      if (repoInfo && repoInfo.directory) {
+        return this._installFromRepoDirectory(repoInfo, { installRoot: this._getOpenCodePluginsDir() });
       }
 
-      const treeMatch = source.match(/github\.com\/([^\/]+)\/([^\/]+)\/tree\/([^\/]+)\/(.+)/);
-      if (treeMatch) {
-        const [, owner, name, branch, directory] = treeMatch;
-        return this._installFromGitHubDirectory({ owner, name, branch, directory }, { installRoot: this._getOpenCodePluginsDir() });
+      const parsedSource = this.parseRepoTreeSource(source);
+      if (parsedSource) {
+        return this._installFromRepoDirectory(parsedSource, { installRoot: this._getOpenCodePluginsDir() });
       }
 
       // OpenCode 原生支持 npm 包名，通过 opencode.json 的 plugin 数组管理
@@ -463,16 +760,13 @@ class PluginsService {
       };
     }
 
-    // If repoInfo is provided, download from GitHub directly
-    if (repoInfo && repoInfo.owner && repoInfo.name && repoInfo.directory) {
-      return await this._installFromGitHubDirectory(repoInfo);
+    if (repoInfo && repoInfo.directory) {
+      return await this._installFromRepoDirectory(repoInfo);
     }
 
-    // Parse tree URL format: https://github.com/owner/repo/tree/branch/path
-    const treeMatch = source.match(/github\.com\/([^\/]+)\/([^\/]+)\/tree\/([^\/]+)\/(.+)/);
-    if (treeMatch) {
-      const [, owner, name, branch, directory] = treeMatch;
-      return await this._installFromGitHubDirectory({ owner, name, branch, directory });
+    const parsedSource = this.parseRepoTreeSource(source);
+    if (parsedSource) {
+      return await this._installFromRepoDirectory(parsedSource);
     }
 
     // Fallback to original git clone method
@@ -480,25 +774,25 @@ class PluginsService {
   }
 
   /**
-   * Install plugin from GitHub directory
+   * Install plugin from repo directory
    * @private
    */
-  async _installFromGitHubDirectory(repoInfo, options = {}) {
-    const { owner, name, branch, directory } = repoInfo;
-    const https = require('https');
+  async _installFromRepoDirectory(repoInfo, options = {}) {
+    const normalizedRepo = this.normalizeRepoConfig(repoInfo);
+    const directory = normalizeRepoPath(repoInfo.directory || '');
     const pluginName = directory.split('/').pop();
     const installRoot = options.installRoot || INSTALLED_DIR;
 
     try {
-      // Fetch plugin.json from the directory
-      const manifestUrl = `https://raw.githubusercontent.com/${owner}/${name}/${branch}/${directory}/plugin.json`;
       let manifest;
-
       try {
-        manifest = await this._fetchJson(manifestUrl);
-      } catch (e) {
-        // No plugin.json, create a basic manifest
-        manifest = { name: pluginName, version: '1.0.0' };
+        manifest = await this.fetchRepoJson(normalizedRepo, `${directory}/plugin.json`);
+      } catch {
+        try {
+          manifest = await this.fetchRepoJson(normalizedRepo, `${directory}/package.json`);
+        } catch {
+          manifest = { name: pluginName, version: '1.0.0' };
+        }
       }
 
       // Create plugin directory
@@ -507,14 +801,55 @@ class PluginsService {
         fs.mkdirSync(pluginDir, { recursive: true });
       }
 
-      // Download all files from the directory
-      const contentsUrl = `https://api.github.com/repos/${owner}/${name}/contents/${directory}?ref=${branch}`;
-      const contents = await this._fetchJson(contentsUrl);
+      if (normalizedRepo.provider === 'local') {
+        const sourceDir = path.join(normalizedRepo.localPath, directory);
+        if (!fs.existsSync(sourceDir)) {
+          throw new Error(`Plugin directory not found: ${directory}`);
+        }
+        this.copyDirRecursive(sourceDir, pluginDir);
+      } else {
+        const tempDir = path.join(os.tmpdir(), `plugin-${Date.now()}`);
+        const zipPath = path.join(tempDir, 'repo.zip');
+        fs.mkdirSync(tempDir, { recursive: true });
+
+        try {
+          let zipUrl = '';
+          let zipHeaders = {};
+
+          if (normalizedRepo.provider === 'gitlab') {
+            const projectId = encodeURIComponent(normalizedRepo.projectPath);
+            zipUrl = `${normalizedRepo.host}/api/v4/projects/${projectId}/repository/archive.zip?sha=${encodeURIComponent(normalizedRepo.branch)}`;
+            const token = this.getGitLabToken(normalizedRepo);
+            if (token) {
+              zipHeaders['PRIVATE-TOKEN'] = token;
+            }
+          } else {
+            zipUrl = `https://api.github.com/repos/${normalizedRepo.owner}/${normalizedRepo.name}/zipball/${encodeURIComponent(normalizedRepo.branch)}`;
+            const token = this.getGitHubToken(normalizedRepo);
+            zipHeaders.Accept = 'application/vnd.github+json';
+            if (token) {
+              zipHeaders.Authorization = `token ${token}`;
+            }
+          }
+
+          await this.downloadFile(zipUrl, zipPath, zipHeaders);
+          const zip = new AdmZip(zipPath);
+          zip.extractAllTo(tempDir, true);
+
+          const extractedDir = fs.readdirSync(tempDir).find(item =>
+            fs.statSync(path.join(tempDir, item)).isDirectory()
+          );
+          if (!extractedDir) {
+            throw new Error('Empty archive');
+          }
 
-      for (const item of contents) {
-        if (item.type === 'file') {
-          const fileContent = await this._fetchRawFile(item.download_url);
-          fs.writeFileSync(path.join(pluginDir, item.name), fileContent);
+          const sourceDir = path.join(tempDir, extractedDir, directory);
+          if (!fs.existsSync(sourceDir)) {
+            throw new Error(`Plugin directory not found: ${directory}`);
+          }
+          this.copyDirRecursive(sourceDir, pluginDir);
+        } finally {
+          fs.rmSync(tempDir, { recursive: true, force: true });
         }
       }
 
@@ -527,7 +862,20 @@ class PluginsService {
       if (!this._isOpenCode()) {
         const installedPluginName = manifest.name || pluginName;
         const installTimestamp = new Date().toISOString();
-        const sourceUrl = `https://github.com/${owner}/${name}/tree/${branch}/${directory}`;
+        const sourceUrl = this.buildRepoBrowserUrl(normalizedRepo, directory) || buildRepoUrl(normalizedRepo);
+        const repoSourceMeta = {
+          repoId: normalizedRepo.id,
+          repoProvider: normalizedRepo.provider,
+          repoOwner: normalizedRepo.owner || '',
+          repoName: normalizedRepo.name || '',
+          repoBranch: normalizedRepo.branch,
+          repoDirectory: directory,
+          repoHost: normalizedRepo.host || '',
+          repoProjectPath: normalizedRepo.projectPath || '',
+          repoLocalPath: normalizedRepo.localPath || '',
+          repoUrl: normalizedRepo.repoUrl || buildRepoUrl(normalizedRepo),
+          source: sourceUrl
+        };
 
         // Register in CTX legacy registry (for listPlugins fallback)
         const { addPlugin } = require('../../plugins/registry');
@@ -542,6 +890,8 @@ class PluginsService {
           console.warn('[PluginsService] Legacy registry addPlugin warning:', e.message);
         }
 
+        this.writeRepoSourceMeta(pluginDir, repoSourceMeta);
+
         // Also register in Claude's native installed_plugins.json
         try {
           this._ensureDir(CLAUDE_PLUGINS_DIR);
@@ -558,7 +908,8 @@ class PluginsService {
             installPath: pluginDir,
             installedAt: installTimestamp,
             scope: 'user',
-            source: sourceUrl
+            source: sourceUrl,
+            ...repoSourceMeta
           }];
           fs.writeFileSync(CLAUDE_INSTALLED_FILE, JSON.stringify(nativeData, null, 2), 'utf8');
         } catch (e) {
@@ -583,26 +934,50 @@ class PluginsService {
   }
 
   /**
-   * Fetch raw file content
+   * Parse GitHub/GitLab tree URL or local path
    * @private
    */
-  async _fetchRawFile(url) {
-    const https = require('https');
-    return new Promise((resolve, reject) => {
-      https.get(url, {
-        headers: { 'User-Agent': 'coding-tool-x' }
-      }, (res) => {
-        let data = '';
-        res.on('data', chunk => data += chunk);
-        res.on('end', () => {
-          if (res.statusCode === 200) {
-            resolve(data);
-          } else {
-            reject(new Error(`HTTP ${res.statusCode}`));
-          }
-        });
-      }).on('error', reject);
-    });
+  parseRepoTreeSource(source = '') {
+    const value = String(source || '').trim();
+    if (!value) return null;
+
+    if (isLikelyLocalPath(value)) {
+      return {
+        provider: 'local',
+        localPath: value,
+        directory: ''
+      };
+    }
+
+    let parsed;
+    try {
+      parsed = new URL(value);
+    } catch {
+      return null;
+    }
+
+    const parts = parsed.pathname.replace(/^\/+|\/+$/g, '').replace(/\.git$/i, '').split('/').filter(Boolean);
+    if (parsed.hostname.includes('github')) {
+      if (parts.length < 4 || parts[2] !== 'tree') return null;
+      return {
+        provider: 'github',
+        host: `${parsed.protocol}//${parsed.host}`,
+        owner: parts[0],
+        name: parts[1],
+        branch: parts[3],
+        directory: parts.slice(4).join('/')
+      };
+    }
+
+    const treeIndex = parts.findIndex((part, index) => part === '-' && parts[index + 1] === 'tree');
+    if (treeIndex < 0 || !parts[treeIndex + 2]) return null;
+    return {
+      provider: 'gitlab',
+      host: `${parsed.protocol}//${parsed.host}`,
+      projectPath: parts.slice(0, treeIndex).join('/'),
+      branch: parts[treeIndex + 2],
+      directory: parts.slice(treeIndex + 3).join('/')
+    };
   }
 
   /**
@@ -837,17 +1212,17 @@ class PluginsService {
     const configPath = this.getReposConfigPath();
     const defaultRepos = this._getDefaultRepos();
     if (!fs.existsSync(configPath)) {
-      return { repos: defaultRepos };
+      return { repos: this.normalizeRepos(defaultRepos) };
     }
     try {
       const parsed = JSON.parse(fs.readFileSync(configPath, 'utf8'));
       if (parsed && Array.isArray(parsed.repos)) {
-        return parsed;
+        return { ...parsed, repos: this.normalizeRepos(parsed.repos) };
       }
-      return { repos: defaultRepos };
+      return { repos: this.normalizeRepos(defaultRepos) };
     } catch (err) {
       console.error('Failed to load repos config:', err);
-      return { repos: defaultRepos };
+      return { repos: this.normalizeRepos(defaultRepos) };
     }
   }
 
@@ -857,7 +1232,8 @@ class PluginsService {
    */
   saveReposConfig(config) {
     const configPath = this.getReposConfigPath();
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+    const normalizedRepos = this.normalizeRepos(config?.repos || []);
+    fs.writeFileSync(configPath, JSON.stringify({ ...(config || {}), repos: normalizedRepos }, null, 2), 'utf8');
   }
 
   /**
@@ -869,10 +1245,16 @@ class PluginsService {
     const repos = [];
     const seenRepos = new Set();
     const pushRepo = (repo) => {
-      if (!repo || !repo.owner || !repo.name) return;
-      const key = `${repo.owner}/${repo.name}`;
+      if (!repo) return;
+      let normalizedRepo;
+      try {
+        normalizedRepo = this.normalizeRepoConfig(repo);
+      } catch {
+        return;
+      }
+      const key = normalizedRepo.id;
       if (seenRepos.has(key)) return;
-      repos.push(repo);
+      repos.push(normalizedRepo);
       seenRepos.add(key);
     };
     const parseRepoUrl = (url) => {
@@ -907,9 +1289,10 @@ class PluginsService {
           const parsed = parseRepoUrl(sourceUrl);
           if (!parsed) continue;
           pushRepo({
+            provider: 'github',
             owner: parsed.owner,
             name: parsed.name,
-            url: parsed.url,
+            repoUrl: parsed.url,
             branch: data?.source?.branch || data?.branch || 'main',
             enabled: data?.enabled !== false,
             source: 'claude-native',
@@ -932,51 +1315,22 @@ class PluginsService {
    */
   addRepo(repo) {
     const config = this.loadReposConfig();
+    const normalizedRepo = this.normalizeRepoConfig({
+      ...repo,
+      addedAt: repo.addedAt || new Date().toISOString()
+    });
+    const existingIndex = config.repos.findIndex(r => r.id === normalizedRepo.id);
 
-    // Parse URL if provided
-    let owner = repo.owner;
-    let name = repo.name;
-    let url = repo.url;
-
-    if (url && !owner && !name) {
-      // Extract owner/name from URL
-      const match = url.match(/github\.com\/([^\/]+)\/([^\/\.]+)/);
-      if (match) {
-        owner = match[1];
-        name = match[2];
-      }
-    }
-
-    if (!owner || !name) {
-      throw new Error('Repository owner and name are required');
-    }
-
-    // Construct URL if not provided
-    if (!url) {
-      url = `https://github.com/${owner}/${name}`;
-    }
-
-    // Check if repo already exists
-    const exists = config.repos.some(r => r.owner === owner && r.name === name);
-    if (exists) {
-      throw new Error(`Repository ${owner}/${name} already exists`);
+    if (existingIndex >= 0) {
+      config.repos[existingIndex] = normalizedRepo;
+    } else {
+      config.repos.push(normalizedRepo);
     }
 
-    // Add new repo
-    const newRepo = {
-      owner,
-      name,
-      url,
-      branch: repo.branch || 'main',
-      enabled: repo.enabled !== false,
-      addedAt: new Date().toISOString()
-    };
-
-    config.repos.push(newRepo);
     this.saveReposConfig(config);
     this.clearMarketCache();
 
-    return config.repos;
+    return this.getRepos();
   }
 
   /**
@@ -985,12 +1339,17 @@ class PluginsService {
    * @param {string} name - Repository name
    * @returns {Array} Updated repos list
    */
-  removeRepo(owner, name) {
+  removeRepo(owner, name, repoId = '') {
     const config = this.loadReposConfig();
-    config.repos = config.repos.filter(r => !(r.owner === owner && r.name === name));
+    config.repos = config.repos.filter(r => {
+      if (repoId) {
+        return r.id !== repoId;
+      }
+      return !(r.owner === owner && r.name === name);
+    });
     this.saveReposConfig(config);
     this.clearMarketCache();
-    return config.repos;
+    return this.getRepos();
   }
 
   /**
@@ -1000,16 +1359,460 @@ class PluginsService {
    * @param {boolean} enabled - Enable or disable
    * @returns {Array} Updated repos list
    */
-  toggleRepo(owner, name, enabled) {
+  toggleRepo(owner, name, enabled, repoId = '') {
     const config = this.loadReposConfig();
-    const repo = config.repos.find(r => r.owner === owner && r.name === name);
+    const repo = config.repos.find(r => {
+      if (repoId) return r.id === repoId;
+      return r.owner === owner && r.name === name;
+    });
     if (!repo) {
-      throw new Error(`Repository ${owner}/${name} not found`);
+      throw new Error('Repository not found');
     }
     repo.enabled = enabled;
     this.saveReposConfig(config);
     this.clearMarketCache();
-    return config.repos;
+    return this.getRepos();
+  }
+
+  updateRepoAuth(owner, name, token = '', clearToken = false, repoId = '') {
+    const config = this.loadReposConfig();
+    const repo = config.repos.find(r => {
+      if (repoId) return r.id === repoId;
+      return r.owner === owner && r.name === name;
+    });
+
+    if (!repo) {
+      throw new Error('Repository not found');
+    }
+
+    if (repo.provider === 'local') {
+      throw new Error('Local repository does not support token auth');
+    }
+
+    if (clearToken) {
+      delete repo.token;
+    } else {
+      const normalizedToken = normalizeRepoToken(token);
+      if (!normalizedToken) {
+        throw new Error('Missing token');
+      }
+      repo.token = normalizedToken;
+    }
+
+    this.saveReposConfig(config);
+    this.clearMarketCache();
+    return this.getRepos();
+  }
+
+  getTokenFromConfigFile(fileName) {
+    try {
+      const configPath = path.join(this.configDir, fileName);
+      if (fs.existsSync(configPath)) {
+        return fs.readFileSync(configPath, 'utf-8').trim() || null;
+      }
+    } catch {
+      // ignore
+    }
+    return null;
+  }
+
+  getTokenFromCommand(command, args = []) {
+    try {
+      const output = execFileSync(command, args, {
+        encoding: 'utf-8',
+        timeout: 3000,
+        stdio: ['ignore', 'pipe', 'ignore'],
+        windowsHide: true
+      }).trim();
+      return output || null;
+    } catch {
+      return null;
+    }
+  }
+
+  getTokenFromGitCredential(host) {
+    const hostname = extractHostname(host);
+    if (!hostname) return null;
+
+    try {
+      const output = execFileSync('git', ['credential', 'fill'], {
+        input: `protocol=https\nhost=${hostname}\n\n`,
+        encoding: 'utf-8',
+        timeout: 3000,
+        stdio: ['pipe', 'pipe', 'ignore'],
+        windowsHide: true
+      });
+      const passwordLine = output
+        .split(/\r?\n/)
+        .find(line => line.startsWith('password='));
+      if (!passwordLine) return null;
+      return passwordLine.slice('password='.length).trim() || null;
+    } catch {
+      return null;
+    }
+  }
+
+  getGitHubToken(repoOrHost = DEFAULT_GITHUB_HOST) {
+    if (repoOrHost && typeof repoOrHost === 'object') {
+      const repoToken = this.resolveRepoToken(repoOrHost);
+      if (repoToken) {
+        return repoToken;
+      }
+    }
+
+    const host = typeof repoOrHost === 'string'
+      ? repoOrHost
+      : (repoOrHost?.host || DEFAULT_GITHUB_HOST);
+
+    if (process.env.GITHUB_TOKEN) {
+      return process.env.GITHUB_TOKEN;
+    }
+
+    const configToken = this.getTokenFromConfigFile('github-token.txt');
+    if (configToken) {
+      return configToken;
+    }
+
+    const hostname = extractHostname(host);
+    if (hostname) {
+      const ghHostToken = this.getTokenFromCommand('gh', ['auth', 'token', '--hostname', hostname]);
+      if (ghHostToken) {
+        return ghHostToken;
+      }
+    }
+
+    const ghToken = this.getTokenFromCommand('gh', ['auth', 'token']);
+    if (ghToken) {
+      return ghToken;
+    }
+
+    return this.getTokenFromGitCredential(host);
+  }
+
+  getGitLabToken(repoOrHost = DEFAULT_GITLAB_HOST) {
+    if (repoOrHost && typeof repoOrHost === 'object') {
+      const repoToken = this.resolveRepoToken(repoOrHost);
+      if (repoToken) {
+        return repoToken;
+      }
+    }
+
+    const host = typeof repoOrHost === 'string'
+      ? repoOrHost
+      : (repoOrHost?.host || DEFAULT_GITLAB_HOST);
+
+    if (process.env.GITLAB_TOKEN) {
+      return process.env.GITLAB_TOKEN;
+    }
+    if (process.env.GITLAB_PRIVATE_TOKEN) {
+      return process.env.GITLAB_PRIVATE_TOKEN;
+    }
+
+    const configToken = this.getTokenFromConfigFile('gitlab-token.txt');
+    if (configToken) {
+      return configToken;
+    }
+
+    const hostname = extractHostname(host);
+    if (hostname) {
+      const glabHostToken = this.getTokenFromCommand('glab', ['auth', 'token', '--hostname', hostname]);
+      if (glabHostToken) {
+        return glabHostToken;
+      }
+    }
+
+    const glabToken = this.getTokenFromCommand('glab', ['auth', 'token']);
+    if (glabToken) {
+      return glabToken;
+    }
+
+    return this.getTokenFromGitCredential(host);
+  }
+
+  async fetchGitHubApi(url, repo = null) {
+    const token = this.getGitHubToken(repo || url);
+    const headers = {
+      'User-Agent': 'coding-tool-x',
+      'Accept': 'application/vnd.github.v3+json'
+    };
+    if (token) {
+      headers.Authorization = `token ${token}`;
+    }
+
+    return new Promise((resolve, reject) => {
+      const req = https.get(url, {
+        headers,
+        timeout: 15000
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          if (res.statusCode === 200) {
+            try {
+              resolve(JSON.parse(data));
+            } catch {
+              reject(new Error('Invalid JSON response'));
+            }
+          } else {
+            reject(new Error(`GitHub API error: ${res.statusCode}`));
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error('Request timeout'));
+      });
+    });
+  }
+
+  async fetchGitLabApi(url, { raw = false, repo = null } = {}) {
+    const token = this.getGitLabToken(repo || url);
+    const headers = {
+      'User-Agent': 'coding-tool-x'
+    };
+    if (!raw) {
+      headers.Accept = 'application/json';
+    }
+    if (token) {
+      headers['PRIVATE-TOKEN'] = token;
+    }
+
+    return new Promise((resolve, reject) => {
+      const transport = url.startsWith('http:') ? http : https;
+      const req = transport.get(url, {
+        headers,
+        timeout: 15000
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          if (res.statusCode === 200) {
+            if (raw) {
+              resolve(data);
+              return;
+            }
+            try {
+              resolve({
+                data: JSON.parse(data),
+                headers: res.headers
+              });
+            } catch {
+              reject(new Error('Invalid JSON response'));
+            }
+          } else {
+            reject(new Error(`GitLab API error: ${res.statusCode}`));
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error('Request timeout'));
+      });
+    });
+  }
+
+  async fetchGitHubRepoTree(repo) {
+    const treeUrl = `https://api.github.com/repos/${repo.owner}/${repo.name}/git/trees/${repo.branch}?recursive=1`;
+    const tree = await this.fetchGitHubApi(treeUrl, repo);
+    return tree?.tree || [];
+  }
+
+  async fetchGitLabTree(repo) {
+    const tree = [];
+    const projectId = encodeURIComponent(repo.projectPath);
+    let page = 1;
+
+    while (page) {
+      const url = `${repo.host}/api/v4/projects/${projectId}/repository/tree?ref=${encodeURIComponent(repo.branch)}&recursive=true&per_page=100&page=${page}`;
+      const response = await this.fetchGitLabApi(url, { repo });
+      tree.push(...(response.data || []).map(item => ({
+        ...item,
+        path: normalizeRepoPath(item.path),
+        type: item.type === 'tree' ? 'tree' : 'blob'
+      })));
+      const nextPage = Number(response.headers['x-next-page'] || 0);
+      page = Number.isFinite(nextPage) && nextPage > 0 ? nextPage : 0;
+    }
+
+    return tree;
+  }
+
+  scanLocalRepoTree(currentDir, repoRoot, tree) {
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith('.')) continue;
+      const fullPath = path.join(currentDir, entry.name);
+      const relativePath = normalizeRepoPath(path.relative(repoRoot, fullPath));
+      if (entry.isDirectory()) {
+        if (entry.name === 'node_modules') continue;
+        tree.push({ path: relativePath, type: 'tree', name: entry.name });
+        this.scanLocalRepoTree(fullPath, repoRoot, tree);
+      } else {
+        tree.push({ path: relativePath, type: 'blob', name: entry.name });
+      }
+    }
+  }
+
+  async fetchLocalRepoTree(repo) {
+    const tree = [];
+    if (!fs.existsSync(repo.localPath)) {
+      throw new Error(`Local repo path not found: ${repo.localPath}`);
+    }
+    this.scanLocalRepoTree(repo.localPath, repo.localPath, tree);
+    return tree;
+  }
+
+  async fetchRepoTree(repo) {
+    if (repo.provider === 'local') {
+      return this.fetchLocalRepoTree(repo);
+    }
+    if (repo.provider === 'gitlab') {
+      return this.fetchGitLabTree(repo);
+    }
+    return this.fetchGitHubRepoTree(repo);
+  }
+
+  async fetchGitHubFileContent(repo, filePath, file = null) {
+    if (file?.sha) {
+      const url = `https://api.github.com/repos/${repo.owner}/${repo.name}/git/blobs/${file.sha}`;
+      const data = await this.fetchGitHubApi(url, repo);
+      if (!data || typeof data.content !== 'string') {
+        throw new Error('Invalid GitHub blob response');
+      }
+      return Buffer.from(data.content.replace(/\n/g, ''), 'base64').toString('utf-8');
+    }
+
+    const normalizedPath = normalizeRepoPath(filePath);
+    const url = `https://api.github.com/repos/${repo.owner}/${repo.name}/contents/${normalizedPath}?ref=${encodeURIComponent(repo.branch)}`;
+    const data = await this.fetchGitHubApi(url, repo);
+    if (typeof data.content !== 'string') {
+      throw new Error('Invalid GitHub contents response');
+    }
+    return Buffer.from(data.content.replace(/\n/g, ''), 'base64').toString('utf-8');
+  }
+
+  async fetchGitLabFileContent(repo, filePath) {
+    const projectId = encodeURIComponent(repo.projectPath);
+    const normalizedFilePath = encodeURIComponent(normalizeRepoPath(filePath));
+    const url = `${repo.host}/api/v4/projects/${projectId}/repository/files/${normalizedFilePath}/raw?ref=${encodeURIComponent(repo.branch)}`;
+    return this.fetchGitLabApi(url, { raw: true, repo });
+  }
+
+  async fetchRepoFileContent(repo, filePath, file = null) {
+    if (repo.provider === 'local') {
+      return fs.readFileSync(path.join(repo.localPath, filePath), 'utf-8');
+    }
+    if (repo.provider === 'gitlab') {
+      return this.fetchGitLabFileContent(repo, filePath);
+    }
+    return this.fetchGitHubFileContent(repo, filePath, file);
+  }
+
+  async fetchRepoJson(repo, filePath, file = null) {
+    const content = await this.fetchRepoFileContent(repo, filePath, file);
+    return JSON.parse(stripJsonComments(content));
+  }
+
+  buildRepoBrowserUrl(repo, filePath = '') {
+    const normalizedPath = normalizeRepoPath(filePath);
+    if (repo.provider === 'local') {
+      return null;
+    }
+    if (repo.provider === 'gitlab') {
+      const suffix = normalizedPath ? `/-/tree/${repo.branch}/${normalizedPath}` : `/-/tree/${repo.branch}`;
+      return `${repo.host}/${repo.projectPath}${suffix}`;
+    }
+    const suffix = normalizedPath ? `tree/${repo.branch}/${normalizedPath}` : `tree/${repo.branch}`;
+    return `${repo.host}/${repo.owner}/${repo.name}/${suffix}`;
+  }
+
+  writeRepoSourceMeta(pluginDir, metadata = {}) {
+    try {
+      fs.writeFileSync(
+        path.join(pluginDir, REPO_SOURCE_META_FILE),
+        JSON.stringify(metadata, null, 2),
+        'utf8'
+      );
+    } catch {
+      // ignore
+    }
+  }
+
+  readRepoSourceMeta(pluginDir) {
+    try {
+      const metaPath = path.join(pluginDir, REPO_SOURCE_META_FILE);
+      if (!fs.existsSync(metaPath)) return null;
+      return JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+    } catch {
+      return null;
+    }
+  }
+
+  copyDirRecursive(sourceDir, destDir) {
+    const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const sourcePath = path.join(sourceDir, entry.name);
+      const destPath = path.join(destDir, entry.name);
+      if (entry.isDirectory()) {
+        if (!fs.existsSync(destPath)) {
+          fs.mkdirSync(destPath, { recursive: true });
+        }
+        this.copyDirRecursive(sourcePath, destPath);
+      } else {
+        fs.copyFileSync(sourcePath, destPath);
+      }
+    }
+  }
+
+  downloadFile(url, destination, headers = {}) {
+    return new Promise((resolve, reject) => {
+      const transport = url.startsWith('http:') ? http : https;
+      const file = fs.createWriteStream(destination);
+
+      const req = transport.get(url, {
+        headers: {
+          'User-Agent': 'coding-tool-x',
+          ...headers
+        },
+        timeout: 30000
+      }, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          file.close(() => {
+            fs.unlink(destination, () => {
+              this.downloadFile(res.headers.location, destination, headers).then(resolve).catch(reject);
+            });
+          });
+          return;
+        }
+
+        if (res.statusCode !== 200) {
+          file.close(() => {
+            fs.unlink(destination, () => reject(new Error(`HTTP ${res.statusCode}`)));
+          });
+          return;
+        }
+
+        res.pipe(file);
+        file.on('finish', () => file.close(resolve));
+      });
+
+      req.on('error', (err) => {
+        file.close(() => {
+          fs.unlink(destination, () => reject(err));
+        });
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        file.close(() => {
+          fs.unlink(destination, () => reject(new Error('Request timeout')));
+        });
+      });
+    });
   }
 
   /**
@@ -1026,16 +1829,21 @@ class PluginsService {
     const { execSync } = require('child_process');
 
     for (const repo of repos.filter(r => r.enabled)) {
+      const repoRef = repo.repoUrl || repo.url || buildRepoUrl(repo);
+      if (!repoRef || repo.provider === 'local') {
+        results.push({ repo: repoRef || repo.id, success: false, error: 'Local repository sync is not supported by Claude marketplace' });
+        continue;
+      }
       try {
-        execSync(`claude plugin marketplace add ${repo.url}`, {
+        execSync(`claude plugin marketplace add ${repoRef}`, {
           encoding: 'utf8',
           timeout: 30000,
           stdio: 'pipe',
           windowsHide: true
         });
-        results.push({ repo: repo.url, success: true });
+        results.push({ repo: repoRef, success: true });
       } catch (err) {
-        results.push({ repo: repo.url, success: false, error: err.message });
+        results.push({ repo: repoRef, success: false, error: err.message });
       }
     }
 
@@ -1050,32 +1858,6 @@ class PluginsService {
     return this.listPlugins();
   }
 
-  /**
-   * Fetch JSON from URL
-   * @private
-   */
-  async _fetchJson(url) {
-    const https = require('https');
-    return new Promise((resolve, reject) => {
-      https.get(url, {
-        headers: {
-          'User-Agent': 'coding-tool-x',
-          'Accept': 'application/vnd.github.v3+json'
-        }
-      }, (res) => {
-        let data = '';
-        res.on('data', chunk => data += chunk);
-        res.on('end', () => {
-          if (res.statusCode === 200) {
-            resolve(JSON.parse(data));
-          } else {
-            reject(new Error(`HTTP ${res.statusCode}: ${data.slice(0, 200)}`));
-          }
-        });
-      }).on('error', reject);
-    });
-  }
-
   /**
    * Get plugin README content
    * @param {Object} plugin - Plugin object with name, repoUrl, source, or repoInfo
@@ -1083,44 +1865,82 @@ class PluginsService {
    */
   async getPluginReadme(plugin) {
     try {
-      let readmeUrl = null;
+      const normalizedDirectory = normalizeRepoPath(plugin.directory || '');
+      const readmeCandidates = [];
+      const pushReadmeCandidates = (directory = '') => {
+        const base = normalizeRepoPath(directory);
+        if (base) {
+          readmeCandidates.push(`${base}/README.md`, `${base}/readme.md`);
+        } else {
+          readmeCandidates.push('README.md', 'readme.md');
+        }
+      };
 
-      // Case 1: Market plugin with repoInfo
-      if (plugin.repoOwner && plugin.repoName && plugin.directory) {
-        const branch = plugin.repoBranch || 'main';
-        readmeUrl = `https://raw.githubusercontent.com/${plugin.repoOwner}/${plugin.repoName}/${branch}/${plugin.directory}/README.md`;
+      if (normalizedDirectory) {
+        pushReadmeCandidates(normalizedDirectory);
       }
-      // Case 2: Installed plugin with source URL
-      else if (plugin.source) {
-        const treeMatch = plugin.source.match(/github\.com\/([^\/]+)\/([^\/]+)\/tree\/([^\/]+)\/(.+)/);
-        if (treeMatch) {
-          const [, owner, name, branch, directory] = treeMatch;
-          readmeUrl = `https://raw.githubusercontent.com/${owner}/${name}/${branch}/${directory}/README.md`;
-        } else {
-          // Try to parse as regular repo URL
-          const repoMatch = plugin.source.match(/github\.com\/([^\/]+)\/([^\/\.]+)/);
-          if (repoMatch) {
-            const [, owner, name] = repoMatch;
-            readmeUrl = `https://raw.githubusercontent.com/${owner}/${name}/main/README.md`;
+      pushReadmeCandidates('');
+
+      if (plugin.installPath && fs.existsSync(plugin.installPath)) {
+        const localCandidates = normalizedDirectory
+          ? [path.join(plugin.installPath, 'README.md'), path.join(plugin.installPath, 'readme.md')]
+          : readmeCandidates.map(candidate => path.join(plugin.installPath, candidate));
+        for (const candidatePath of localCandidates) {
+          if (fs.existsSync(candidatePath)) {
+            return fs.readFileSync(candidatePath, 'utf8');
           }
         }
       }
-      // Case 3: Plugin with repoUrl
-      else if (plugin.repoUrl) {
-        const match = plugin.repoUrl.match(/github\.com\/([^\/]+)\/([^\/\.]+)/);
-        if (match) {
-          const [, owner, name] = match;
-          readmeUrl = `https://raw.githubusercontent.com/${owner}/${name}/main/README.md`;
+
+      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 (!readmeUrl) {
-        return '';
+      if (!repo) return '';
+
+      for (const candidate of readmeCandidates) {
+        try {
+          return await this.fetchRepoFileContent(repo, candidate);
+        } catch {
+          // try next candidate
+        }
       }
 
-      // Fetch README content
-      const content = await this._fetchRawFile(readmeUrl);
-      return content;
+      return '';
     } catch (err) {
       console.error('[PluginsService] Failed to fetch README:', err.message);
       return '';
@@ -1136,29 +1956,48 @@ class PluginsService {
     };
   }
 
+  buildMarketPluginItem(repo, data = {}) {
+    return {
+      name: data.name,
+      displayName: data.displayName || '',
+      description: data.description || '',
+      author: data.author || repo.owner || repo.projectPath || 'unknown',
+      version: data.version || '1.0.0',
+      category: data.category || 'general',
+      repoUrl: data.repoUrl || repo.repoUrl || buildRepoUrl(repo),
+      repoProvider: repo.provider,
+      repoOwner: repo.owner || '',
+      repoName: repo.name || '',
+      repoBranch: repo.branch || 'main',
+      repoHost: repo.host || '',
+      repoProjectPath: repo.projectPath || '',
+      repoLocalPath: repo.localPath || '',
+      repoId: repo.id,
+      directory: normalizeRepoPath(data.directory || data.name || ''),
+      installSource: data.installSource || '',
+      marketplaceFormat: data.marketplaceFormat || '',
+      readmeUrl: this.buildRepoBrowserUrl(repo, data.directory || data.name || ''),
+      lspServers: data.lspServers || null,
+      commands: data.commands || [],
+      hooks: data.hooks || [],
+      isInstalled: false
+    };
+  }
+
   async _fetchOpenCodeMarketplacePlugins(repo, branch) {
     if (!this._isOpenCode()) return [];
 
-    let entries;
-    try {
-      const indexUrl = `https://api.github.com/repos/${repo.owner}/${repo.name}/contents/plugins?ref=${branch}`;
-      entries = await this._fetchJson(indexUrl);
-    } catch (err) {
-      return [];
-    }
-
-    if (!Array.isArray(entries)) return [];
-
-    const manifestFiles = entries.filter(
-      item => item.type === 'file' && item.name.endsWith('.plugin.json')
+    const tree = await this.fetchRepoTree(repo);
+    const manifestFiles = tree.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 fileUrl = file.download_url ||
-          `https://raw.githubusercontent.com/${repo.owner}/${repo.name}/${branch}/${file.path}`;
-        const manifest = await this._fetchJson(fileUrl);
+        const manifest = await this.fetchRepoJson(repo, file.path, file);
 
         const author = Array.isArray(manifest.authors)
           ? manifest.authors.map(item => item?.name).filter(Boolean).join(', ')
@@ -1170,22 +2009,18 @@ class PluginsService {
         const installSource = String(manifest.name || '').trim();
         const githubRepo = this._parseGitHubRepo(repoUrl);
 
-        return {
+        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',
-          repoUrl,
-          repoOwner: '',
-          repoName: '',
-          repoBranch: githubRepo ? 'main' : branch,
           directory: file.path,
-          installSource,
+          installSource: githubRepo ? '' : installSource,
           marketplaceFormat: 'opencode-plugin-json',
-          isInstalled: false
-        };
+          repoUrl
+        });
       })
     );
 
@@ -1224,42 +2059,43 @@ class PluginsService {
     let repoFailureCount = 0;
 
     for (const repo of repos) {
-      const repoLabel = repo.owner ? `${repo.owner}/${repo.name}` : repo.url;
+      const repoLabel = repo.label || repo.repoUrl || repo.localPath || `${repo.owner || ''}/${repo.name || ''}`;
       const pluginsBefore = marketPlugins.length;
       try {
-        const branch = repo.branch || 'main';
+        const tree = await this.fetchRepoTree(repo);
+        const files = tree.filter(item => item.type === 'blob');
+        const fileMap = new Map(files.map(file => [normalizeRepoPath(file.path), file]));
+        const readJson = async (filePath) => {
+          const normalizedPath = normalizeRepoPath(filePath);
+          const file = fileMap.get(normalizedPath);
+          if (!file) {
+            throw new Error(`File not found: ${normalizedPath}`);
+          }
+          return this.fetchRepoJson(repo, normalizedPath, file);
+        };
 
         // Try to fetch marketplace.json first (official format)
-        try {
-          const marketplaceUrl = `https://raw.githubusercontent.com/${repo.owner}/${repo.name}/${branch}/.claude-plugin/marketplace.json`;
-          const marketplace = await this._fetchJson(marketplaceUrl);
-
+        if (fileMap.has('.claude-plugin/marketplace.json')) {
+          const marketplace = await readJson('.claude-plugin/marketplace.json');
           if (marketplace && marketplace.plugins) {
             for (const plugin of marketplace.plugins) {
-              marketPlugins.push({
+              marketPlugins.push(this.buildMarketPluginItem(repo, {
                 name: plugin.name,
                 description: plugin.description || '',
                 author: plugin.author?.name || marketplace.owner?.name || repo.owner,
                 version: plugin.version || '1.0.0',
                 category: plugin.category || 'general',
-                repoUrl: `https://github.com/${repo.owner}/${repo.name}`,
-                repoOwner: repo.owner,
-                repoName: repo.name,
-                repoBranch: branch,
                 directory: plugin.source?.replace(/^\.\//, '') || plugin.name,
-                lspServers: plugin.lspServers || null,
-                isInstalled: false
-              });
+                lspServers: plugin.lspServers || null
+              }));
             }
             continue; // Skip legacy format check
           }
-        } catch (e) {
-          // marketplace.json not found, try legacy format
         }
 
         // OpenCode plugin marketplace format: plugins/*.plugin.json
         if (this._isOpenCode()) {
-          const openCodeMarketplacePlugins = await this._fetchOpenCodeMarketplacePlugins(repo, branch);
+          const openCodeMarketplacePlugins = await this._fetchOpenCodeMarketplacePlugins(repo, repo.branch || 'main');
           if (openCodeMarketplacePlugins.length > 0) {
             marketPlugins.push(...openCodeMarketplacePlugins);
             continue;
@@ -1267,48 +2103,37 @@ class PluginsService {
         }
 
         // Legacy format: each directory is a plugin with plugin.json/package.json
-        const apiUrl = `https://api.github.com/repos/${repo.owner}/${repo.name}/contents?ref=${branch}`;
-        const contents = await this._fetchJson(apiUrl);
-        const pluginDirs = contents.filter(item => item.type === 'dir' && !item.name.startsWith('.'));
+        const pluginDirs = Array.from(new Set(
+          files
+            .map(item => item.path.split('/')[0])
+            .filter(dir => dir && !dir.startsWith('.') && dir !== 'node_modules')
+        ));
 
         for (const dir of pluginDirs) {
           try {
-            const manifestUrl = `https://raw.githubusercontent.com/${repo.owner}/${repo.name}/${branch}/${dir.name}/plugin.json`;
-            const manifest = await this._fetchJson(manifestUrl);
+            const manifest = await readJson(`${dir}/plugin.json`);
 
-            marketPlugins.push({
-              name: manifest.name || dir.name,
+            marketPlugins.push(this.buildMarketPluginItem(repo, {
+              name: manifest.name || dir,
               description: manifest.description || '',
               author: manifest.author || repo.owner,
               version: manifest.version || '1.0.0',
-              repoUrl: `https://github.com/${repo.owner}/${repo.name}`,
-              repoOwner: repo.owner,
-              repoName: repo.name,
-              repoBranch: branch,
-              directory: dir.name,
+              directory: dir,
               commands: manifest.commands || [],
-              hooks: manifest.hooks || [],
-              isInstalled: false
-            });
+              hooks: manifest.hooks || []
+            }));
           } catch (e) {
             // OpenCode 仓库常见 package.json 格式
             if (this._isOpenCode()) {
               try {
-                const pkgUrl = `https://raw.githubusercontent.com/${repo.owner}/${repo.name}/${branch}/${dir.name}/package.json`;
-                const pkg = await this._fetchJson(pkgUrl);
-                const pluginName = pkg.name || dir.name;
-                marketPlugins.push({
-                  name: pluginName,
+                const pkg = await readJson(`${dir}/package.json`);
+                marketPlugins.push(this.buildMarketPluginItem(repo, {
+                  name: pkg.name || dir,
                   description: pkg.description || '',
                   author: pkg.author || repo.owner,
                   version: pkg.version || '1.0.0',
-                  repoUrl: `https://github.com/${repo.owner}/${repo.name}`,
-                  repoOwner: repo.owner,
-                  repoName: repo.name,
-                  repoBranch: branch,
-                  directory: dir.name,
-                  isInstalled: false
-                });
+                  directory: dir
+                }));
               } catch (pkgErr) {
                 // neither plugin.json nor package.json
               }