coding-tool-x 3.8.4 → 3.8.5

package/src/{server/services → platforms}/agents-service.js

@@ -10,18 +10,42 @@ const path = require('path');
 const os = require('os');
 const toml = require('toml');
 const tomlStringify = require('@iarna/toml').stringify;
-const { RepoScannerBase } = require('./repo-scanner-base');
-const { NATIVE_PATHS } = require('../../config/paths');
-const { resolvePreferredHomeDir } = require('../../utils/home-dir');
+const { RepoScannerBase } = require('../server/services/repo-scanner-base');
+const { LocalResourceIndex } = require('../server/services/local-resource-index');
+const { NATIVE_PATHS } = require('../config/paths');
+const { resolvePreferredHomeDir } = require('../utils/home-dir');
+const { createPlatformAccessError } = require('./access');
+const { getPlatformContext } = require('../server/platform-context');
 const {
   normalizeSafeFileStem,
   normalizeSafeRelativePath,
   resolveInsideRoot
-} = require('./config-artifact-paths');
+} = require('../shared/config-artifact-paths');
+
+function readAgentMetadata(filePath) {
+  const fd = fs.openSync(filePath, 'r');
+  const buffer = Buffer.alloc(8192);
+  const chunks = [];
+  let total = 0;
+  try {
+    while (total < 1024 * 1024) {
+      const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, null);
+      if (!bytesRead) break;
+      chunks.push(Buffer.from(buffer.subarray(0, bytesRead)));
+      total += bytesRead;
+      let text = Buffer.concat(chunks).toString('utf8');
+      if (text.charCodeAt(0) === 0xFEFF) text = text.slice(1);
+      if (total === bytesRead && !/^\s*---\s*(?:\n|$)/.test(text)) return {};
+      if (/^\s*---\s*\n[\s\S]*?\n\s*---\s*(?:\n|$)/.test(text)) return parseFrontmatter(text).frontmatter;
+    }
+    return {};
+  } finally {
+    fs.closeSync(fd);
+  }
+}
 
 // 默认仓库源
 const DEFAULT_REPOS = [];
-const SUPPORTED_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode'];
 const OPENCODE_CONFIG_DIR = NATIVE_PATHS.opencode.config;
 const CODEX_CONFIG_PATH = NATIVE_PATHS.codex.config;
 const HOME_DIR = resolvePreferredHomeDir(process.platform, process.env, os.homedir());
@@ -35,7 +59,8 @@ const PLATFORM_CONFIG = {
   claude: {
     userAgentsDir: CLAUDE_AGENTS_DIR,
     projectAgentsDir: (projectPath) => path.join(projectPath, '.claude', 'agents'),
-    repoType: 'agents'
+    repoType: 'agents',
+    capabilities: { projectScope: true, repoOperations: true }
   },
   opencode: {
     userAgentsDir: path.join(OPENCODE_CONFIG_DIR, 'agents'),
@@ -48,24 +73,33 @@ const PLATFORM_CONFIG = {
       }
       return modern;
     },
-    repoType: 'opencode-agents'
+    repoType: 'opencode-agents',
+    capabilities: { projectScope: true, repoOperations: true }
   },
   codex: {
     userAgentsDir: CODEX_AGENTS_DIR,
     projectAgentsDir: () => null,
-    repoType: 'agents'
+    repoType: 'agents',
+    capabilities: { projectScope: false, repoOperations: false }
   },
   gemini: {
     userAgentsDir: GEMINI_AGENTS_DIR,
     projectAgentsDir: (projectPath) => path.join(projectPath, '.gemini', 'agents'),
-    repoType: 'gemini-agents'
+    repoType: 'gemini-agents',
+    capabilities: { projectScope: true, repoOperations: true }
   }
 };
 
 function normalizePlatform(platform) {
-  const normalized = typeof platform === 'string' && platform.trim() ? platform.trim() : 'claude';
-  if (!SUPPORTED_PLATFORMS.includes(normalized)) {
-    throw new Error(`不支持的平台: ${platform}`);
+  const normalized = typeof platform === 'string' && platform.trim()
+    ? platform.trim().toLowerCase()
+    : 'claude';
+  if (!Object.prototype.hasOwnProperty.call(PLATFORM_CONFIG, normalized)) {
+    throw createPlatformAccessError('unsupported', {
+      platform: normalized,
+      capability: 'agents',
+      message: `Agents are not supported for ${normalized}`
+    });
   }
   return normalized;
 }
@@ -137,31 +171,31 @@ function writeFileAtomic(filePath, content) {
   fs.renameSync(tempPath, filePath);
 }
 
-function readCodexTomlConfig() {
-  if (!fs.existsSync(CODEX_CONFIG_PATH)) {
+function readCodexTomlConfig(configPath = CODEX_CONFIG_PATH) {
+  if (!fs.existsSync(configPath)) {
     return {};
   }
 
   try {
-    const content = fs.readFileSync(CODEX_CONFIG_PATH, 'utf-8');
+    const content = fs.readFileSync(configPath, 'utf-8');
     return toml.parse(content);
   } catch (err) {
     throw new Error(`读取 Codex config.toml 失败: ${err.message}`);
   }
 }
 
-function writeCodexTomlConfig(config) {
-  ensureDir(path.dirname(CODEX_CONFIG_PATH));
-  writeFileAtomic(CODEX_CONFIG_PATH, tomlStringify(config));
+function writeCodexTomlConfig(config, configPath = CODEX_CONFIG_PATH) {
+  ensureDir(path.dirname(configPath));
+  writeFileAtomic(configPath, tomlStringify(config));
 }
 
 function isPlainObject(value) {
   return !!value && typeof value === 'object' && !Array.isArray(value);
 }
 
-function getCodexManagedAgentConfigPath(fileName) {
+function getCodexManagedAgentConfigPath(fileName, agentsDir = CODEX_AGENTS_DIR) {
   const safeFileName = assertSafeAgentFileName(fileName);
-  return resolveInsideRoot(CODEX_AGENTS_DIR, `${safeFileName}.toml`, 'Codex agent config path');
+  return resolveInsideRoot(agentsDir, `${safeFileName}.toml`, 'Codex agent config path');
 }
 
 function normalizeCodexConfigPath(configPath) {
@@ -207,34 +241,34 @@ function assertSafeCodexConfigPath(configPath) {
   return relative;
 }
 
-function resolveCodexConfigPath(configPath) {
+function resolveCodexConfigPath(configPath, configBasePath = CODEX_CONFIG_PATH, homeDir = HOME_DIR) {
   const normalized = normalizeCodexConfigPath(configPath);
   if (!normalized) return '';
 
   if (normalized.startsWith('~/')) {
-    return path.join(HOME_DIR, normalized.slice(2));
+    return path.join(homeDir, normalized.slice(2));
   }
 
   if (path.isAbsolute(normalized)) {
     return normalized;
   }
 
-  return path.resolve(path.dirname(CODEX_CONFIG_PATH), normalized);
+  return path.resolve(path.dirname(configBasePath), normalized);
 }
 
-function isManagedCodexConfigPath(configPath) {
-  const resolved = resolveCodexConfigPath(configPath);
+function isManagedCodexConfigPath(configPath, configBasePath = CODEX_CONFIG_PATH, agentsDir = CODEX_AGENTS_DIR, homeDir = HOME_DIR) {
+  const resolved = resolveCodexConfigPath(configPath, configBasePath, homeDir);
   if (!resolved) return false;
-  const managedRoot = path.resolve(CODEX_AGENTS_DIR) + path.sep;
-  return resolved.startsWith(managedRoot) || resolved === path.resolve(CODEX_AGENTS_DIR);
+  const managedRoot = path.resolve(agentsDir) + path.sep;
+  return resolved.startsWith(managedRoot) || resolved === path.resolve(agentsDir);
 }
 
-function getManagedCodexConfigResolvedPath(configPath) {
+function getManagedCodexConfigResolvedPath(configPath, configBasePath = CODEX_CONFIG_PATH, agentsDir = CODEX_AGENTS_DIR, homeDir = HOME_DIR) {
   const normalized = normalizeCodexConfigPath(configPath);
-  if (!normalized || !isManagedCodexConfigPath(normalized)) {
+  if (!normalized || !isManagedCodexConfigPath(normalized, configBasePath, agentsDir, homeDir)) {
     return '';
   }
-  return resolveCodexConfigPath(normalized);
+  return resolveCodexConfigPath(normalized, configBasePath, homeDir);
 }
 
 function normalizeCodexConfigMode(mode) {
@@ -317,6 +351,7 @@ function readCodexAgentConfigFile(configFilePath) {
  * 解析 YAML frontmatter
  */
 function parseFrontmatter(content) {
+
   const result = {
     frontmatter: {},
     body: content
@@ -354,6 +389,32 @@ function parseFrontmatter(content) {
 
   return result;
 }
+function readCodexTomlMetadata(filePath) {
+  const fd = fs.openSync(filePath, 'r');
+  const buffer = Buffer.alloc(8192);
+  const chunks = [];
+  let total = 0;
+  let updatedAt = 0;
+  try {
+    updatedAt = fs.fstatSync(fd).mtimeMs;
+    while (total < 1024 * 1024) {
+      const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, null);
+      if (!bytesRead) break;
+      chunks.push(Buffer.from(buffer.subarray(0, bytesRead)));
+      total += bytesRead;
+      let content = Buffer.concat(chunks).toString('utf8');
+      if (content.charCodeAt(0) === 0xFEFF) content = content.slice(1);
+      if (/^\s*model\s*=.*(?:\n|$)/m.test(content)) return { data: toml.parse(content), content, updatedAt };
+    }
+    let content = Buffer.concat(chunks).toString('utf8');
+    if (content.charCodeAt(0) === 0xFEFF) content = content.slice(1);
+    return { data: toml.parse(content), content, updatedAt };
+  } catch (error) {
+    return { data: {}, content: '', updatedAt, error };
+  } finally {
+    fs.closeSync(fd);
+  }
+}
 
 /**
  * 生成 frontmatter 字符串
@@ -536,21 +597,122 @@ class AgentsRepoScanner extends RepoScannerBase {
  * Agents 服务类
  */
 class AgentsService {
-  constructor(platform = 'claude') {
+  constructor(platform = 'claude', { registry } = {}) {
     this.platform = normalizePlatform(platform);
     const config = PLATFORM_CONFIG[this.platform];
-
-    this.userAgentsDir = config.userAgentsDir;
+    this.registry = registry || (() => {
+      try {
+        return getPlatformContext().registry;
+      } catch {
+        return null;
+      }
+    })();
+    this.pathContext = null;
+    try {
+      if (typeof this.registry?.resolvePathContext === 'function') {
+        this.pathContext = this.registry.resolvePathContext(this.platform);
+      }
+    } catch {
+      this.pathContext = null;
+    }
+    const native = this.pathContext?.customized
+      ? (this.pathContext.native || {})
+      : (NATIVE_PATHS[this.platform] || {});
+    this.homeDir = this.pathContext?.customized ? this.pathContext.home : HOME_DIR;
+    this.codexConfigPath = this.platform === 'codex'
+      ? (native.config || CODEX_CONFIG_PATH)
+      : CODEX_CONFIG_PATH;
+    this.codexAgentsDir = this.platform === 'codex'
+      ? (native.agents || path.join(native.dir || path.dirname(this.codexConfigPath), 'agents'))
+      : CODEX_AGENTS_DIR;
+    const configuredUserAgentsDir = this.pathContext?.customized
+      ? (native.agents
+        || (this.platform === 'opencode' ? path.join(native.config || OPENCODE_CONFIG_DIR, 'agents') : null)
+        || (native.dir ? path.join(native.dir, 'agents') : null))
+      : null;
+    this.userAgentsDir = configuredUserAgentsDir || config.userAgentsDir;
     if (this.platform === 'opencode') {
       const legacyUserDir = config.legacyUserAgentsDir;
-      if (legacyUserDir && fs.existsSync(legacyUserDir) && !fs.existsSync(this.userAgentsDir)) {
-        this.userAgentsDir = legacyUserDir;
-      }
+      const configuredLegacyUserDir = this.pathContext?.customized && native.config
+        ? path.join(native.config, 'agent')
+        : legacyUserDir;
+      if (configuredLegacyUserDir && fs.existsSync(configuredLegacyUserDir) && !fs.existsSync(this.userAgentsDir)) this.userAgentsDir = configuredLegacyUserDir;
     }
-
     this.projectAgentsDir = config.projectAgentsDir;
     this.repoScanner = new AgentsRepoScanner(this.platform, this.userAgentsDir);
     ensureDir(this.userAgentsDir);
+    this._localIndexes = new Map();
+    this._localIndexLimit = 32;
+  }
+  _readCodexTomlConfig() {
+    return readCodexTomlConfig(this.codexConfigPath);
+  }
+  _writeCodexTomlConfig(config) {
+    return writeCodexTomlConfig(config, this.codexConfigPath);
+  }
+  _resolveCodexConfigPath(configPath) {
+    return resolveCodexConfigPath(configPath, this.codexConfigPath, this.homeDir);
+  }
+  _isManagedCodexConfigPath(configPath) {
+    return isManagedCodexConfigPath(configPath, this.codexConfigPath, this.codexAgentsDir, this.homeDir);
+  }
+  _getCodexManagedAgentConfigPath(fileName) {
+    return getCodexManagedAgentConfigPath(fileName, this.codexAgentsDir);
+  }
+  _inferCodexConfigMode(configFile) {
+    const normalized = normalizeCodexConfigPath(configFile);
+    if (!normalized) return 'none';
+    return this._isManagedCodexConfigPath(normalized) ? 'managed' : 'custom';
+  }
+  _configUpdatedAt() {
+    return fs.existsSync(this.codexConfigPath) ? fs.statSync(this.codexConfigPath).mtime.getTime() : 0;
+  }
+  getCapabilities() {
+    return { ...(PLATFORM_CONFIG[this.platform]?.capabilities || { projectScope: true, repoOperations: true }) };
+  }
+  getRepoOperationError(operation = '') {
+    const suffix = operation === 'install' ? '安装' : operation === 'uninstall' ? '卸载' : '';
+    return `${this.platform === 'codex' ? 'Codex 平台' : '该平台'}暂不支持远程仓库代理${suffix}`;
+  }
+  _getLocalIndex(scope, projectPath = null) {
+    const root = scope === 'user' ? this.userAgentsDir : this.getProjectAgentsDir(projectPath);
+    if (!root) return null;
+    const key = `${this.platform}:${scope}:${path.resolve(root)}`;
+    if (!this._localIndexes.has(key)) {
+      if (this._localIndexes.size >= this._localIndexLimit) {
+        const [oldKey, oldIndex] = this._localIndexes.entries().next().value;
+        oldIndex.dispose();
+        this._localIndexes.delete(oldKey);
+      }
+      this._localIndexes.set(key, new LocalResourceIndex({ key, roots: [root],
+        scanFile: (descriptor) => {
+          if (!descriptor.fullPath.endsWith('.md') || descriptor.relativePath.includes(path.sep)) return null;
+          const frontmatter = readAgentMetadata(descriptor.fullPath);
+          const fileName = path.basename(descriptor.relativePath, '.md');
+          return { name: frontmatter.name || fileName, fileName, scope, path: descriptor.relativePath, fullPath: descriptor.fullPath, description: frontmatter.description || '', tools: frontmatter.tools || '', model: frontmatter.model || '', permissionMode: frontmatter.permissionMode || '', skills: frontmatter.skills || '', updatedAt: descriptor.stat.mtime.getTime() };
+        },
+        detailFile: (summary) => {
+          const content = fs.readFileSync(summary.fullPath, 'utf-8');
+          const { frontmatter, body } = parseFrontmatter(content);
+          return { systemPrompt: body, fullContent: content, updatedAt: fs.statSync(summary.fullPath).mtime.getTime(), name: frontmatter.name || summary.fileName, description: frontmatter.description || '', tools: frontmatter.tools || '', model: frontmatter.model || '', permissionMode: frontmatter.permissionMode || '', skills: frontmatter.skills || '' };
+        }
+      }));
+    }
+    const index = this._localIndexes.get(key);
+    this._localIndexes.delete(key);
+    this._localIndexes.set(key, index);
+    return index;
+  }
+
+  dispose() {
+    for (const index of this._localIndexes.values()) index.dispose();
+    this._localIndexes.clear();
+    this._codexIndex?.dispose();
+    this._codexIndex = null;
+  }
+
+  _invalidateLocal(scope, projectPath = null) {
+    this._getLocalIndex(scope, projectPath)?.invalidate();
   }
 
   getProjectAgentsDir(projectPath) {
@@ -575,52 +737,20 @@ class AgentsService {
     return { safeFileName, relativePath, fullPath };
   }
 
-  /**
-   * 获取所有代理列表
-   * @param {string} projectPath - 项目路径（可选，用于获取项目级代理）
-   */
   listAgents(projectPath = null) {
-    if (this.platform === 'codex') {
-      return this.listCodexAgents();
-    }
-
-    const agents = [];
-
-    // 获取用户级代理
-    const userAgents = scanAgentsDir(this.userAgentsDir, this.userAgentsDir, 'user');
-    agents.push(...userAgents);
-
-    // 获取项目级代理（如果提供了项目路径）
-    if (projectPath) {
-      const projectAgentsDir = this.getProjectAgentsDir(projectPath);
-      const projectAgents = scanAgentsDir(projectAgentsDir, projectAgentsDir, 'project');
-      agents.push(...projectAgents);
-    }
-
-    // 按名称排序
+    if (this.platform === 'codex') return this.listCodexAgents(false);
+    const userAgents = this._getLocalIndex('user').listSync();
+    const projectAgents = projectPath ? this._getLocalIndex('project', projectPath).listSync() : [];
+    const agents = [...userAgents, ...projectAgents];
     agents.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
-
-    return {
-      agents,
-      total: agents.length,
-      userCount: userAgents.length,
-      projectCount: agents.length - userAgents.length
-    };
+    return { agents, total: agents.length, userCount: userAgents.length, projectCount: projectAgents.length };
   }
 
-  /**
-   * 获取所有代理（包括远程仓库）
-   */
+  /** 获取所有代理（包括远程仓库） */
   async listAllAgents(projectPath = null, forceRefresh = false) {
     if (this.platform === 'codex') {
-      const { agents, userCount, projectCount } = this.listCodexAgents();
-      return {
-        agents,
-        total: agents.length,
-        userCount,
-        projectCount,
-        remoteCount: 0
-      };
+      const { agents, userCount, projectCount } = this.listCodexAgents(false);
+      return { agents, total: agents.length, userCount, projectCount, remoteCount: 0 };
     }
 
     // 获取本地代理
@@ -666,36 +796,12 @@ class AgentsService {
    */
   getAgent(fileName, scope, projectPath = null) {
     const safeFileName = assertSafeAgentFileName(fileName);
-
-    if (this.platform === 'codex') {
-      return this.getCodexAgent(safeFileName, scope);
-    }
-
+    if (this.platform === 'codex') return this.getCodexAgent(safeFileName, scope);
     const baseDir = this._getBaseDir(scope, projectPath);
-    const { relativePath, fullPath: filePath } = this._resolveAgentFilePath(baseDir, safeFileName);
-
-    if (!fs.existsSync(filePath)) {
-      return null;
-    }
-
-    const content = fs.readFileSync(filePath, 'utf-8');
-    const { frontmatter, body } = parseFrontmatter(content);
-
-    return {
-      name: frontmatter.name || safeFileName,
-      fileName: safeFileName,
-      scope,
-      path: relativePath,
-      fullPath: filePath,
-      description: frontmatter.description || '',
-      tools: frontmatter.tools || '',
-      model: frontmatter.model || '',
-      permissionMode: frontmatter.permissionMode || '',
-      skills: frontmatter.skills || '',
-      systemPrompt: body,
-      fullContent: content,
-      updatedAt: fs.statSync(filePath).mtime.getTime()
-    };
+    const { relativePath } = this._resolveAgentFilePath(baseDir, safeFileName);
+    const detail = this._getLocalIndex(scope, projectPath)?.getSync(relativePath);
+    if (!detail) return null;
+    return { ...detail, fileName: safeFileName, scope, path: relativePath };
   }
 
   /**
@@ -734,9 +840,8 @@ class AgentsService {
     if (skills) frontmatterData.skills = skills;
 
     const content = generateFrontmatter(frontmatterData, this.platform) + '\n\n' + (systemPrompt || '');
-
     fs.writeFileSync(filePath, content, 'utf-8');
-
+    this._invalidateLocal(scope, projectPath);
     return this.getAgent(safeFileName, scope, projectPath);
   }
 
@@ -768,9 +873,8 @@ class AgentsService {
     if (skills) frontmatterData.skills = skills;
 
     const content = generateFrontmatter(frontmatterData, this.platform) + '\n\n' + (systemPrompt || '');
-
     fs.writeFileSync(filePath, content, 'utf-8');
-
+    this._invalidateLocal(scope, projectPath);
     return this.getAgent(safeFileName, scope, projectPath);
   }
 
@@ -792,7 +896,7 @@ class AgentsService {
     }
 
     fs.unlinkSync(filePath);
-
+    this._invalidateLocal(scope, projectPath);
     return { success: true, message: '代理已删除' };
   }
 
@@ -864,28 +968,24 @@ class AgentsService {
    * 从远程仓库安装代理
    */
   async installFromRemote(agent) {
-    if (!agent || typeof agent !== 'object') {
-      throw new Error('无效的代理安装参数');
-    }
+    if (!agent || typeof agent !== 'object') throw new Error('无效的代理安装参数');
     const safeFileName = assertSafeAgentFileName(agent.fileName);
     const safeRepoPath = assertSafeRepoPath(agent.repoPath);
-    return this.repoScanner.installAgent({
-      ...agent,
-      fileName: safeFileName,
-      repoPath: safeRepoPath
-    });
+    const result = await this.repoScanner.installAgent({ ...agent, fileName: safeFileName, repoPath: safeRepoPath });
+    if (result && result.success !== false) this._invalidateLocal('user');
+    return result;
   }
 
-  /**
-   * 卸载代理
-   */
+  /** 卸载代理 */
   uninstallAgent(fileName) {
     const safeFileName = assertSafeAgentFileName(fileName);
-    return this.repoScanner.uninstall(`${safeFileName}.md`);
+    const result = this.repoScanner.uninstall(`${safeFileName}.md`);
+    if (result && result.success !== false) this._invalidateLocal('user');
+    return result;
   }
 
-  listCodexAgents() {
-    const config = readCodexTomlConfig();
+  _readCodexAgents(includeDetails = true) {
+    const config = this._readCodexTomlConfig();
     const agentsTable = isPlainObject(config.agents) ? config.agents : {};
     const agentsByName = new Map();
 
@@ -895,26 +995,19 @@ class AgentsService {
       }
 
       const configFile = normalizeCodexConfigPath(value.config_file);
-      const resolvedConfigFile = resolveCodexConfigPath(configFile);
-      const configMode = inferCodexConfigMode(configFile);
+      const resolvedConfigFile = this._resolveCodexConfigPath(configFile);
+      const configMode = this._inferCodexConfigMode(configFile);
       const fullPath = configFile || `${key}.toml`;
       let model = '';
       let fullContent = '';
       let configReadError = '';
-      let updatedAt = fs.existsSync(CODEX_CONFIG_PATH) ? fs.statSync(CODEX_CONFIG_PATH).mtime.getTime() : Date.now();
-
-      if (configFile) {
+      let updatedAt = this.codexConfigPath && fs.existsSync(this.codexConfigPath) ? fs.statSync(this.codexConfigPath).mtime.getTime() : Date.now();
+      if (includeDetails && configFile) {
         const parsedConfigFile = readCodexAgentConfigFile(resolvedConfigFile);
         fullContent = parsedConfigFile.content;
-        if (isPlainObject(parsedConfigFile.data) && typeof parsedConfigFile.data.model === 'string') {
-          model = parsedConfigFile.data.model;
-        }
-        if (parsedConfigFile.updatedAt) {
-          updatedAt = Math.max(updatedAt, parsedConfigFile.updatedAt);
-        }
-        if (parsedConfigFile.error) {
-          configReadError = parsedConfigFile.error;
-        }
+        if (isPlainObject(parsedConfigFile.data) && typeof parsedConfigFile.data.model === 'string') model = parsedConfigFile.data.model;
+        if (parsedConfigFile.updatedAt) updatedAt = Math.max(updatedAt, parsedConfigFile.updatedAt);
+        if (parsedConfigFile.error) configReadError = parsedConfigFile.error;
       }
 
       agentsByName.set(key, {
@@ -939,9 +1032,9 @@ class AgentsService {
       });
     }
 
-    if (fs.existsSync(CODEX_AGENTS_DIR)) {
+    if (fs.existsSync(this.codexAgentsDir)) {
       try {
-        const entries = fs.readdirSync(CODEX_AGENTS_DIR, { withFileTypes: true });
+        const entries = fs.readdirSync(this.codexAgentsDir, { withFileTypes: true });
         for (const entry of entries) {
           if (!entry.isFile() || !entry.name.endsWith('.toml')) {
             continue;
@@ -954,35 +1047,25 @@ class AgentsService {
             continue;
           }
 
-          const configFilePath = path.join(CODEX_AGENTS_DIR, entry.name);
-          const parsedConfigFile = readCodexAgentConfigFile(configFilePath);
+          const configFilePath = path.join(this.codexAgentsDir, entry.name);
+          const parsedConfigFile = includeDetails ? readCodexAgentConfigFile(configFilePath) : { content: '', data: null, updatedAt: fs.statSync(configFilePath).mtime.getTime(), error: null };
           const existing = agentsByName.get(fileName);
-          const model = isPlainObject(parsedConfigFile.data) && typeof parsedConfigFile.data.model === 'string'
-            ? parsedConfigFile.data.model
-            : '';
+          const model = isPlainObject(parsedConfigFile.data) && typeof parsedConfigFile.data.model === 'string' ? parsedConfigFile.data.model : '';
           const updatedAt = parsedConfigFile.updatedAt || fs.statSync(configFilePath).mtime.getTime();
 
           if (existing) {
             if (!existing.configFile) {
               existing.configFile = configFilePath;
-              existing.configMode = inferCodexConfigMode(configFilePath);
+              existing.configMode = this._inferCodexConfigMode(configFilePath);
               existing.path = configFilePath;
               existing.fullPath = configFilePath;
               existing.resolvedConfigFile = configFilePath;
             }
-            if (!existing.fullContent && parsedConfigFile.content) {
-              existing.fullContent = parsedConfigFile.content;
-            }
-            if (!existing.model && model) {
-              existing.model = model;
-            }
-            if (parsedConfigFile.error && !existing.configReadError) {
-              existing.configReadError = parsedConfigFile.error;
-            }
+            if (includeDetails && !existing.fullContent && parsedConfigFile.content) existing.fullContent = parsedConfigFile.content;
+            if (!existing.model && model) existing.model = model;
+            if (parsedConfigFile.error && !existing.configReadError) existing.configReadError = parsedConfigFile.error;
             existing.updatedAt = Math.max(existing.updatedAt || 0, updatedAt);
-            existing.source = existing.source === 'codex-config'
-              ? 'codex-config+native-file'
-              : existing.source;
+            existing.source = existing.source === 'codex-config' ? 'codex-config+native-file' : existing.source;
             continue;
           }
 
@@ -1000,7 +1083,7 @@ class AgentsService {
             systemPrompt: '',
             fullContent: parsedConfigFile.content,
             configFile: configFilePath,
-            configMode: inferCodexConfigMode(configFilePath),
+            configMode: this._inferCodexConfigMode(configFilePath),
             configReadError: parsedConfigFile.error || '',
             resolvedConfigFile: configFilePath,
             updatedAt,
@@ -1012,27 +1095,101 @@ class AgentsService {
       }
     }
 
-    const agents = Array.from(agentsByName.values());
 
+    const agents = Array.from(agentsByName.values());
     agents.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
+    return { agents, total: agents.length, userCount: agents.length, projectCount: 0 };
+  }
+  _getCodexIndex() {
+    if (!this._codexIndex) {
+      this._codexIndex = new LocalResourceIndex({
+        key: `${this.platform}:codex`, roots: [this.codexAgentsDir], ttlMs: 1000,
+        scanFile: ({ fullPath, relativePath, stat }) => {
+          if (!fullPath.endsWith('.toml') || relativePath.includes(path.sep)) return null;
+          const fileName = path.basename(fullPath, '.toml');
+          const metadata = readCodexTomlMetadata(fullPath);
+          const data = metadata.data || {};
+          return { name: fileName, fileName, scope: 'user', path: fullPath, fullPath, description: '', tools: '', model: typeof data.model === 'string' ? data.model : '', permissionMode: '', skills: '', configFile: fullPath, configMode: 'managed', resolvedConfigFile: fullPath, configReadError: metadata.error?.message || '', updatedAt: stat.mtime.getTime(), source: 'native-file' };
+        },
+        detailFile: (summary) => this._hydrateCodexAgent(summary)
+      });
+    }
+    return this._codexIndex;
+  }
 
+  _hydrateCodexAgent(summary) {
+    const configPath = summary.resolvedConfigFile || this._resolveCodexConfigPath(summary.configFile) || (summary.source === 'native-file' ? summary.fullPath : '');
+    if (!configPath) return { ...summary, fullContent: '', systemPrompt: '', configReadError: '' };
+    const parsed = readCodexAgentConfigFile(configPath);
+    const data = parsed.data || {};
     return {
-      agents,
-      total: agents.length,
-      userCount: agents.length,
-      projectCount: 0
+      ...summary,
+      model: typeof data.model === 'string' ? data.model : summary.model || '',
+      fullContent: parsed.content,
+      systemPrompt: '',
+      configReadError: parsed.error || summary.configReadError || '',
+      updatedAt: parsed.updatedAt || summary.updatedAt
     };
   }
 
-  getCodexAgent(fileName, scope) {
-    assertSafeAgentFileName(fileName);
-
-    if (scope !== 'user') {
-      return null;
+  listCodexAgents(includeDetails = true) {
+    const indexed = this._getCodexIndex().listSync();
+    const config = this._readCodexTomlConfig();
+    const table = isPlainObject(config.agents) ? config.agents : {};
+    const merged = new Map(indexed.map((agent) => [agent.fileName, { ...agent }]));
+    for (const [fileName, entry] of Object.entries(table)) {
+      if (!isPlainObject(entry)) continue;
+      const configFile = normalizeCodexConfigPath(entry.config_file);
+      const resolvedConfigFile = this._resolveCodexConfigPath(configFile);
+      const existing = merged.get(fileName);
+      const externalMetadata = configFile && !this._isManagedCodexConfigPath(configFile) && fs.existsSync(resolvedConfigFile)
+        ? readCodexTomlMetadata(resolvedConfigFile)
+        : { data: {}, error: null };
+      const summary = {
+        ...(existing || {
+          name: fileName, fileName, scope: 'user', path: configFile || `${fileName}.toml`,
+          fullPath: resolvedConfigFile || `${fileName}.toml`, tools: '', model: '',
+          permissionMode: '', skills: '', updatedAt: this._configUpdatedAt(), source: 'codex-config'
+        }),
+        description: entry.description || existing?.description || '',
+        model: existing?.model || (typeof externalMetadata.data?.model === 'string' ? externalMetadata.data.model : ''),
+        configReadError: externalMetadata.error?.message || existing?.configReadError || '',
+        updatedAt: externalMetadata.updatedAt || existing?.updatedAt || this._configUpdatedAt(),
+        configFile: configFile || existing?.configFile || '',
+        configMode: this._inferCodexConfigMode(configFile || existing?.configFile || ''),
+        resolvedConfigFile: resolvedConfigFile || existing?.resolvedConfigFile || existing?.fullPath || '',
+        source: existing ? 'codex-config+native-file' : 'codex-config'
+      };
+      merged.set(fileName, summary);
     }
+    const agents = Array.from(merged.values()).map((summary) => includeDetails ? this._hydrateCodexAgent(summary) : summary);
+    agents.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
+    return { agents, total: agents.length, userCount: agents.length, projectCount: 0 };
+  }
 
-    const { agents } = this.listCodexAgents();
-    return agents.find(agent => agent.fileName === fileName) || null;
+  getCodexAgent(fileName, scope) {
+    const safeFileName = assertSafeAgentFileName(fileName);
+    if (scope !== 'user') return null;
+    const config = this._readCodexTomlConfig();
+    const entry = isPlainObject(config.agents) && isPlainObject(config.agents[safeFileName]) ? config.agents[safeFileName] : null;
+    const managedPath = path.join(this.codexAgentsDir, `${safeFileName}.toml`);
+    const configFile = normalizeCodexConfigPath(entry?.config_file);
+    const resolvedConfigFile = this._resolveCodexConfigPath(configFile);
+    const nativePath = !configFile && fs.existsSync(managedPath) ? managedPath : '';
+    const exists = Boolean(entry || nativePath || (resolvedConfigFile && fs.existsSync(resolvedConfigFile)));
+    if (!exists) return null;
+    const targetPath = resolvedConfigFile || nativePath;
+    const summary = {
+      name: safeFileName, fileName: safeFileName, scope: 'user',
+      path: targetPath || `${safeFileName}.toml`, fullPath: targetPath || `${safeFileName}.toml`,
+      description: entry?.description || '', tools: '', model: '', permissionMode: '', skills: '',
+      configFile: configFile || nativePath,
+      configMode: this._inferCodexConfigMode(configFile || nativePath),
+      resolvedConfigFile: targetPath,
+      updatedAt: this._configUpdatedAt(),
+      source: entry ? 'codex-config' : 'native-file'
+    };
+    return this._hydrateCodexAgent(summary);
   }
 
   createCodexAgent({ fileName, scope, description, model, configMode, configFile, configContent }) {
@@ -1046,7 +1203,7 @@ class AgentsService {
       throw new Error('代理描述不能为空');
     }
 
-    const config = readCodexTomlConfig();
+    const config = this._readCodexTomlConfig();
     config.features = isPlainObject(config.features) ? config.features : {};
     config.features.multi_agent = true;
     config.agents = isPlainObject(config.agents) ? config.agents : {};
@@ -1064,20 +1221,20 @@ class AgentsService {
     if (!normalizedMode) {
       const trimmedModel = (model || '').trim();
       if (trimmedModel) {
-        ensureDir(CODEX_AGENTS_DIR);
-        const configFilePath = getCodexManagedAgentConfigPath(fileName);
+        ensureDir(this.codexAgentsDir);
+        const configFilePath = this._getCodexManagedAgentConfigPath(fileName);
         writeFileAtomic(configFilePath, tomlStringify({ model: trimmedModel }));
         agentConfig.config_file = configFilePath;
       }
     } else if (normalizedMode === 'managed') {
-      ensureDir(CODEX_AGENTS_DIR);
-      const configFilePath = getCodexManagedAgentConfigPath(fileName);
+      ensureDir(this.codexAgentsDir);
+      const configFilePath = this._getCodexManagedAgentConfigPath(fileName);
       const content = resolveCodexConfigContent({ configContent, model });
       writeFileAtomic(configFilePath, content);
       agentConfig.config_file = configFilePath;
     } else if (normalizedMode === 'custom') {
       const safeConfigFile = assertSafeCodexConfigPath(configFile);
-      const resolvedPath = resolveCodexConfigPath(safeConfigFile);
+      const resolvedPath = this._resolveCodexConfigPath(safeConfigFile);
       ensureDir(path.dirname(resolvedPath));
       const content = resolveCodexConfigContent({ configContent, model });
       writeFileAtomic(resolvedPath, content);
@@ -1085,8 +1242,8 @@ class AgentsService {
     }
 
     config.agents[fileName] = agentConfig;
-    writeCodexTomlConfig(config);
-
+    this._writeCodexTomlConfig(config);
+    this._codexIndex?.invalidate();
     return this.getCodexAgent(fileName, scope);
   }
 
@@ -1097,7 +1254,7 @@ class AgentsService {
       throw new Error('Codex 仅支持用户级代理');
     }
 
-    const config = readCodexTomlConfig();
+    const config = this._readCodexTomlConfig();
     config.features = isPlainObject(config.features) ? config.features : {};
     config.features.multi_agent = true;
     config.agents = isPlainObject(config.agents) ? config.agents : {};
@@ -1111,16 +1268,16 @@ class AgentsService {
     agentConfig.description = (description || '').trim();
 
     const existingConfigFile = normalizeCodexConfigPath(agentConfig.config_file);
-    const isExistingManagedConfig = isManagedCodexConfigPath(existingConfigFile);
-    const resolvedExistingConfigFile = isExistingManagedConfig ? resolveCodexConfigPath(existingConfigFile) : '';
+    const isExistingManagedConfig = this._isManagedCodexConfigPath(existingConfigFile);
+    const resolvedExistingConfigFile = isExistingManagedConfig ? this._resolveCodexConfigPath(existingConfigFile) : '';
     const normalizedMode = normalizeCodexConfigMode(configMode);
 
     if (!normalizedMode) {
       const trimmedModel = (model || '').trim();
       if (trimmedModel) {
-        ensureDir(CODEX_AGENTS_DIR);
-        const configFilePath = isExistingManagedConfig ? existingConfigFile : getCodexManagedAgentConfigPath(fileName);
-        const resolvedConfigFilePath = resolveCodexConfigPath(configFilePath);
+        ensureDir(this.codexAgentsDir);
+        const configFilePath = isExistingManagedConfig ? existingConfigFile : this._getCodexManagedAgentConfigPath(fileName);
+        const resolvedConfigFilePath = this._resolveCodexConfigPath(configFilePath);
         const parsedConfigFile = readCodexAgentConfigFile(resolvedConfigFilePath);
         const configFileData = isPlainObject(parsedConfigFile?.data) ? parsedConfigFile.data : {};
         configFileData.model = trimmedModel;
@@ -1139,9 +1296,9 @@ class AgentsService {
         fs.unlinkSync(resolvedExistingConfigFile);
       }
     } else if (normalizedMode === 'managed') {
-      ensureDir(CODEX_AGENTS_DIR);
-      const configFilePath = getCodexManagedAgentConfigPath(fileName);
-      const resolvedConfigFilePath = resolveCodexConfigPath(configFilePath);
+      ensureDir(this.codexAgentsDir);
+      const configFilePath = this._getCodexManagedAgentConfigPath(fileName);
+      const resolvedConfigFilePath = this._resolveCodexConfigPath(configFilePath);
       const existingManagedContent = fs.existsSync(resolvedConfigFilePath)
         ? fs.readFileSync(resolvedConfigFilePath, 'utf-8')
         : '';
@@ -1170,7 +1327,7 @@ class AgentsService {
         targetConfigPath = assertSafeCodexConfigPath(targetConfigPath);
       }
 
-      const resolvedTargetConfigPath = resolveCodexConfigPath(targetConfigPath);
+      const resolvedTargetConfigPath = this._resolveCodexConfigPath(targetConfigPath);
       const existingContent = fs.existsSync(resolvedTargetConfigPath)
         ? fs.readFileSync(resolvedTargetConfigPath, 'utf-8')
         : '';
@@ -1190,8 +1347,8 @@ class AgentsService {
     }
 
     config.agents[fileName] = agentConfig;
-    writeCodexTomlConfig(config);
-
+    this._writeCodexTomlConfig(config);
+    this._codexIndex?.invalidate();
     return this.getCodexAgent(fileName, scope);
   }
 
@@ -1202,7 +1359,7 @@ class AgentsService {
       throw new Error('Codex 仅支持用户级代理');
     }
 
-    const config = readCodexTomlConfig();
+    const config = this._readCodexTomlConfig();
     config.agents = isPlainObject(config.agents) ? config.agents : {};
 
     const existingAgent = config.agents[fileName];
@@ -1211,17 +1368,17 @@ class AgentsService {
     }
 
     const existingConfigFile = normalizeCodexConfigPath(existingAgent.config_file);
-    const resolvedExistingConfigFile = resolveCodexConfigPath(existingConfigFile);
+    const resolvedExistingConfigFile = this._resolveCodexConfigPath(existingConfigFile);
     if (existingConfigFile &&
-        isManagedCodexConfigPath(existingConfigFile) &&
+        this._isManagedCodexConfigPath(existingConfigFile) &&
         resolvedExistingConfigFile &&
         fs.existsSync(resolvedExistingConfigFile)) {
       fs.unlinkSync(resolvedExistingConfigFile);
     }
 
     delete config.agents[fileName];
-    writeCodexTomlConfig(config);
-
+    this._writeCodexTomlConfig(config);
+    this._codexIndex?.invalidate();
     return { success: true, message: '代理已删除' };
   }
 }