coding-tool-x 3.8.4 → 3.8.5

package/src/platforms/channel-auth-registry.js

@@ -0,0 +1,162 @@
+'use strict';
+
+const { readAllNativeOAuth } = require('./native-oauth-adapters');
+const oauthStore = require('./oauth-credentials-service');
+const { getOmpAuthProviderSnapshot } = require('./drivers/omp/auth-providers');
+
+function getRegistry() {
+  return require('./registry').createPlatformRegistry();
+}
+
+function safeRef(value = {}) {
+  return {
+    credentialId: String(value.credentialId || '').trim(),
+    providerId: String(value.providerId || '').trim(),
+    accountId: String(value.accountId || '').trim(),
+    identityKey: String(value.identityKey || '').trim(),
+    accountEmail: String(value.accountEmail || '').trim()
+  };
+}
+
+function nativeCandidate(adapter, metadata, credential) {
+  const ref = safeRef({
+    credentialId: credential?.id,
+    providerId: metadata.providerId || credential?.providerId,
+    accountId: metadata.accountId || credential?.accountId,
+    identityKey: metadata.identityKey,
+    accountEmail: metadata.accountEmail || credential?.accountEmail
+  });
+  return {
+    id: ref.credentialId || `${adapter}:${ref.accountId || ref.identityKey || ref.accountEmail || ref.providerId}`,
+    tool: adapter,
+    authMode: 'oauth',
+    authRef: ref,
+    authSource: 'synced-local',
+    authStatus: 'available',
+    providerId: ref.providerId,
+    accountId: ref.accountId,
+    accountEmail: ref.accountEmail,
+    expiresAt: credential?.expiresAt || metadata.expiresAt || null,
+    lastSyncAt: credential?.updatedAt || new Date().toISOString()
+  };
+}
+
+function scanNative(adapter) {
+  const native = readAllNativeOAuth(adapter) || [];
+  const synced = native.length ? oauthStore.syncLocalCredential(adapter) : null;
+  const credentials = synced?.credentials || [];
+  const candidates = native.map((metadata, index) => nativeCandidate(adapter, metadata, credentials[index]));
+  return {
+    candidates,
+    nativeState: {
+      available: candidates.length > 0,
+      candidateCount: candidates.length,
+      checkedAt: new Date().toISOString()
+    },
+    warnings: candidates.length ? [] : [`${adapter}: unavailable: no local OAuth credential`]
+  };
+}
+
+function scanOmp() {
+  const snapshot = getOmpAuthProviderSnapshot({ forceRefresh: true, accountCheck: true });
+  const hasAccounts = (snapshot.providers || []).some(provider => (
+    provider.loggedIn === true && Array.isArray(provider.accounts) && provider.accounts.length > 0
+  ));
+  let synced = null;
+  if (hasAccounts) {
+    try {
+      synced = oauthStore.syncLocalCredential('omp');
+    } catch {
+      synced = null;
+    }
+  }
+  const credentials = synced?.credentials || [];
+  const candidates = [];
+  for (const provider of snapshot.providers || []) {
+    if (provider.loggedIn !== true || !Array.isArray(provider.accounts) || provider.accounts.length === 0) continue;
+    for (const account of provider.accounts) {
+      const accountId = account.id || account.accountId || account.index;
+      const accountEmail = account.email || account.accountEmail || account.identity;
+      const identityKey = account.identityKey || accountEmail || accountId;
+      const credential = credentials.find(item => (
+        item.providerId === provider.id
+        && (item.accountId === String(accountId || '') || item.accountEmail === String(accountEmail || ''))
+      ));
+      const ref = safeRef({
+        credentialId: credential?.id,
+        providerId: provider.id,
+        accountId,
+        identityKey,
+        accountEmail
+      });
+      if (!ref.accountId && !ref.identityKey && (provider.accounts || []).length > 1) continue;
+      candidates.push({
+        id: credential?.id || `omp:${provider.id}:${ref.accountId || ref.identityKey || 'account'}`,
+        tool: 'omp',
+        authMode: 'oauth',
+        authRef: ref,
+        authSource: 'synced-local',
+        authStatus: ref.accountId || ref.identityKey ? 'available' : 'ambiguous',
+        oauthProviderId: provider.id,
+        providerId: provider.id,
+        accountId: ref.accountId,
+        accountEmail: ref.accountEmail
+      });
+    }
+  }
+  return {
+    candidates,
+    nativeState: { available: snapshot.available === true, providers: snapshot.providers || [], checkedAt: snapshot.checkedAt },
+    warnings: candidates.length ? [] : [snapshot.reason || 'omp: unavailable: no logged-in local provider']
+  };
+}
+
+const adapters = Object.freeze({
+  claude: {
+    scan: () => scanNative('claude'),
+    quota: (ref) => oauthStore.fetchCredentialUsage('claude', ref.credentialId),
+    channelServicePath: './drivers/claude/channels-implementation'
+  },
+  codex: {
+    scan: () => scanNative('codex'),
+    quota: (ref) => oauthStore.fetchCredentialUsage('codex', ref.credentialId),
+    channelServicePath: './drivers/codex/channels-implementation'
+  },
+  gemini: {
+    scan: () => scanNative('gemini'),
+    quota: (ref) => oauthStore.fetchCredentialUsage('gemini', ref.credentialId),
+    channelServicePath: './drivers/gemini/channels-implementation'
+  },
+  omp: {
+    scan: scanOmp,
+    quota: async () => ({ status: 'unavailable', error: 'OMP native OAuth quota is unavailable' }),
+    channelServicePath: './drivers/omp/channels-implementation'
+  }
+});
+
+function getOAuthManifests() {
+  return getRegistry().list({ enabledOnly: false }).filter(manifest => (
+    manifest.auth?.oauth?.adapter && adapters[manifest.auth.oauth.adapter]
+  ));
+}
+function getChannelAuthAdapter(platform) {
+  const key = String(platform || '').trim().toLowerCase();
+  const manifest = getOAuthManifests().find(item => item.key === key);
+  const adapterId = manifest?.auth?.oauth?.adapter;
+  const adapter = adapterId ? adapters[adapterId] : null;
+  if (!adapter) return null;
+  return {
+    ...adapter,
+    platform: manifest.key,
+    adapterId,
+    policy: manifest.auth.oauth.policy,
+    quotaId: manifest.auth.oauth.quota || null
+  };
+}
+
+function listChannelAuthPlatforms() {
+  return getOAuthManifests().map(manifest => manifest.key);
+}
+
+
+module.exports = { getChannelAuthAdapter, listChannelAuthPlatforms, safeRef };

package/src/platforms/channel-auth-service.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const { getChannelAuthAdapter, listChannelAuthPlatforms, safeRef } = require('./channel-auth-registry');
+
+const quotaCache = new Map();
+const QUOTA_TTL_MS = 5 * 60 * 1000;
+
+function getAdapter(platform) {
+  const adapter = getChannelAuthAdapter(platform);
+  if (!adapter) throw new Error(`Unsupported channel auth platform: ${platform}`);
+  return adapter;
+}
+
+function matchChannel(channel, candidate) {
+  if (!channel || channel.authMode !== 'oauth') return false;
+  const ref = safeRef(channel.authRef);
+  const next = safeRef(candidate.authRef);
+  if (ref.credentialId && next.credentialId) return ref.credentialId === next.credentialId;
+  if (ref.providerId && next.providerId && (ref.accountId || ref.identityKey) && (next.accountId || next.identityKey)) {
+    return ref.providerId === next.providerId
+      && (ref.accountId || ref.identityKey) === (next.accountId || next.identityKey);
+  }
+  return false;
+}
+
+function getChannel(platform, channelId) {
+  if (!channelId) return null;
+  const adapter = getAdapter(platform);
+  const service = require(adapter.channelServicePath);
+  return (service.getChannels?.().channels || []).find(channel => channel.id === channelId) || null;
+}
+
+function getChannelAuth(platform, { channelId = '' } = {}) {
+  const adapter = getAdapter(platform);
+  const result = adapter.scan();
+  return {
+    channel: getChannel(platform, channelId),
+    candidates: result.candidates || [],
+    nativeState: result.nativeState || { available: false },
+    warnings: result.warnings || []
+  };
+}
+
+function syncLocalChannelAuth(platform, options = {}) {
+  return getChannelAuth(platform, options);
+}
+
+async function fetchChannelAuthQuota(platform, channelId, { refresh = false } = {}) {
+  const adapter = getAdapter(platform);
+  const checkedAt = () => new Date().toISOString();
+  const channel = getChannel(platform, channelId);
+  if (!channel) return { quota: null, status: 'unavailable', checkedAt: checkedAt(), warning: 'Channel not found' };
+  if (channel.authMode !== 'oauth') return { quota: null, status: 'unsupported', checkedAt: checkedAt(), warning: 'Channel is not OAuth' };
+  const ref = safeRef(channel.authRef);
+  const cacheKey = `${adapter.adapterId}:${ref.credentialId || ref.providerId}:${ref.accountId || ref.identityKey}`;
+  const cached = quotaCache.get(cacheKey);
+  if (!refresh && cached && Date.now() - cached.checkedAtMs < QUOTA_TTL_MS) return cached.value;
+  try {
+    const usage = await adapter.quota(ref);
+    const result = {
+      ...(usage?.quota ? usage : {
+        quota: null,
+        status: usage?.status || 'unavailable',
+        warning: usage?.error || 'Quota unavailable'
+      }),
+      checkedAt: checkedAt()
+    };
+    quotaCache.set(cacheKey, { checkedAtMs: Date.now(), value: result });
+    return result;
+  } catch (error) {
+    return { quota: null, status: 'unavailable', checkedAt: checkedAt(), warning: error.message };
+  }
+}
+
+module.exports = {
+  getChannelAuth,
+  syncLocalChannelAuth,
+  fetchChannelAuthQuota,
+  listChannelAuthPlatforms,
+  safeRef,
+  matchChannel
+};

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

@@ -9,20 +9,73 @@ const fs = require('fs');
 const path = require('path');
 const toml = require('toml');
 const tomlStringify = require('@iarna/toml').stringify;
-const { RepoScannerBase } = require('./repo-scanner-base');
-const { NATIVE_PATHS } = require('../../config/paths');
+const { NATIVE_PATHS } = require('../config/paths');
+const { RepoScannerBase } = require('../server/services/repo-scanner-base');
+const { LocalResourceIndex } = require('../server/services/local-resource-index');
+const { createPlatformAccessError } = require('./access');
+const { getPlatformContext } = require('../server/platform-context');
 const {
   parseFrontmatter
-} = require('./format-converter');
+} = require('../server/services/format-converter');
 const {
   normalizeSafeFileStem,
   normalizeSafeRelativePath,
   resolveInsideRoot
-} = require('./config-artifact-paths');
+} = require('../shared/config-artifact-paths');
+
+function readMetadataPrefix(filePath, platform) {
+  const fd = fs.openSync(filePath, 'r');
+  const buffer = Buffer.alloc(8192);
+  const chunks = [];
+  let total = 0;
+  const isGemini = platform === 'gemini';
+  try {
+    while (total < (isGemini ? 64 * 1024 : 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 (!isGemini && total === bytesRead && !/^\s*---\s*(?:\n|$)/.test(text)) break;
+      if (isGemini && /^\s*description\s*=.*(?:\n|$)/m.test(text)) break;
+      if (!isGemini && /^\s*---\s*\n[\s\S]*?\n\s*---\s*(?:\n|$)/.test(text)) break;
+    }
+    let result = Buffer.concat(chunks).toString('utf8');
+    if (result.charCodeAt(0) === 0xFEFF) result = result.slice(1);
+    if (isGemini && !/^\s*description\s*=/m.test(result)) {
+      const stat = fs.fstatSync(fd);
+      if (stat.size > total) {
+        const remaining = stat.size - total;
+        const tailSize = Math.min(1024 * 1024, remaining);
+        const offset = remaining <= 1024 * 1024 ? total : stat.size - tailSize;
+        const tail = Buffer.alloc(tailSize);
+        const bytesRead = fs.readSync(fd, tail, 0, tailSize, offset);
+        result += `\n${tail.toString('utf8', 0, bytesRead)}`;
+      }
+    }
+    return result;
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+function parseCommandMetadata(filePath, platform) {
+  const content = readMetadataPrefix(filePath, platform);
+  if (platform === 'gemini') {
+    try {
+      const parsed = toml.parse(content);
+      return { frontmatter: {}, gemini: { description: parsed.description || '' } };
+    } catch (error) {
+      const match = content.match(/^\s*description\s*=\s*(.+)$/m);
+      return { frontmatter: {}, gemini: { description: match ? match[1].trim().replace(/^['"]|['"]$/g, '') : '', parseError: error.message } };
+    }
+  }
+  return { ...parseFrontmatter(content), gemini: null };
+}
 
 // 默认仓库源
 const DEFAULT_REPOS = [];
-const SUPPORTED_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode', 'omp'];
 const OPENCODE_CONFIG_DIR = NATIVE_PATHS.opencode.config;
 const CLAUDE_COMMANDS_DIR = NATIVE_PATHS.claude.commands
   || path.join(NATIVE_PATHS.claude.dir || path.dirname(NATIVE_PATHS.claude.settings), 'commands');
@@ -67,7 +120,17 @@ const PLATFORM_CONFIG = {
 };
 
 function normalizePlatform(platform) {
-  return SUPPORTED_PLATFORMS.includes(platform) ? platform : 'claude';
+  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: 'commands',
+      message: `Commands are not supported for ${normalized}`
+    });
+  }
+  return normalized;
 }
 
 /**
@@ -165,12 +228,9 @@ function parseGeminiCommandToml(content) {
 }
 
 function generateGeminiCommandToml({ description, body }) {
-  const data = {
-    prompt: body || ''
-  };
-  if (description) {
-    data.description = description;
-  }
+  const data = {};
+  if (description) data.description = description;
+  data.prompt = body || '';
   return tomlStringify(data);
 }
 
@@ -338,23 +398,114 @@ class CommandsRepoScanner extends RepoScannerBase {
  * Commands 服务类
  */
 class CommandsService {
-  constructor(platform = 'claude') {
+  constructor(platform = 'claude', { registry } = {}) {
     this.platform = normalizePlatform(platform);
     const config = PLATFORM_CONFIG[this.platform];
-
-    this.userCommandsDir = config.userCommandsDir;
+    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] || {});
+    const configuredUserCommandsDir = this.pathContext?.customized
+      ? (native.commands
+        || (this.platform === 'opencode' ? path.join(native.config || OPENCODE_CONFIG_DIR, 'commands') : null)
+        || (native.dir ? path.join(native.dir, 'commands') : null))
+      : null;
+
+    this.userCommandsDir = configuredUserCommandsDir || config.userCommandsDir;
     if (this.platform === 'opencode') {
       const legacyUserDir = config.legacyUserCommandsDir;
-      if (legacyUserDir && fs.existsSync(legacyUserDir) && !fs.existsSync(this.userCommandsDir)) {
-        this.userCommandsDir = legacyUserDir;
+      const configuredLegacyUserDir = this.pathContext?.customized && native.config
+        ? path.join(native.config, 'command')
+        : legacyUserDir;
+      if (configuredLegacyUserDir && fs.existsSync(configuredLegacyUserDir) && !fs.existsSync(this.userCommandsDir)) {
+        this.userCommandsDir = configuredLegacyUserDir;
       }
     }
 
     this.projectCommandsDir = config.projectCommandsDir;
     this.repoScanner = new CommandsRepoScanner(this.platform, this.userCommandsDir);
     ensureDir(this.userCommandsDir);
+    this._localIndexes = new Map();
+    this._localIndexLimit = 32;
+  }
+
+  _getLocalIndex(scope, projectPath = null) {
+    const root = scope === 'user' ? this.userCommandsDir : this.getProjectCommandsDir(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);
+      }
+      const extension = getCommandFileExtension(this.platform);
+      this._localIndexes.set(key, new LocalResourceIndex({ key, roots: [root],
+        scanFile: (descriptor) => {
+          if (!descriptor.fullPath.endsWith(extension)) return null;
+          const parsed = parseCommandMetadata(descriptor.fullPath, this.platform);
+          const relativePath = descriptor.relativePath;
+          const commandName = path.basename(relativePath, extension);
+          const namespace = path.dirname(relativePath);
+          return {
+            name: commandName,
+            namespace: namespace === '.' ? null : namespace,
+            scope,
+            path: relativePath,
+            fullPath: descriptor.fullPath,
+            description: parsed.gemini?.description || parsed.frontmatter.description || '',
+            allowedTools: parsed.frontmatter['allowed-tools'] || '',
+            argumentHint: parsed.frontmatter['argument-hint'] || '',
+            agent: parsed.frontmatter.agent || '',
+            model: parsed.frontmatter.model || '',
+            subtask: parsed.frontmatter.subtask || '',
+            parseError: parsed.gemini?.parseError || '',
+            updatedAt: descriptor.stat.mtime.getTime()
+          };
+        },
+        detailFile: (summary) => {
+          const content = fs.readFileSync(summary.fullPath, 'utf-8');
+          const parsed = this.platform === 'gemini'
+            ? { frontmatter: {}, body: '', gemini: parseGeminiCommandToml(content) }
+            : { ...parseFrontmatter(content), gemini: null };
+          return {
+            body: parsed.gemini?.body ?? parsed.body,
+            fullContent: content,
+            parseError: parsed.gemini?.parseError || '',
+            updatedAt: fs.statSync(summary.fullPath).mtime.getTime()
+          };
+        }
+      }));
+    }
+    const index = this._localIndexes.get(key);
+    this._localIndexes.delete(key);
+    this._localIndexes.set(key, index);
+    return index;
+  }
+
+  _invalidateLocal(scope, projectPath = null) {
+    this._getLocalIndex(scope, projectPath)?.invalidate();
   }
 
+
+  dispose() {
+    for (const index of this._localIndexes.values()) index.dispose();
+    this._localIndexes.clear();
+  }
   getProjectCommandsDir(projectPath) {
     if (!projectPath) return null;
     return this.projectCommandsDir(projectPath);
@@ -406,133 +557,60 @@ class CommandsService {
    * @param {string} projectPath - 项目路径（可选，用于获取项目级命令）
    */
   listCommands(projectPath = null) {
-    const commands = [];
-
-    // 获取用户级命令
-    const userCommands = scanCommandsDir(this.userCommandsDir, this.userCommandsDir, 'user', this.platform);
-    commands.push(...userCommands);
-
-    // 获取项目级命令（如果提供了项目路径）
-    if (projectPath) {
-      const projectCommandsDir = this.getProjectCommandsDir(projectPath);
-      const projectCommands = scanCommandsDir(projectCommandsDir, projectCommandsDir, 'project', this.platform);
-      commands.push(...projectCommands);
-    }
-
-    // 按名称排序
+    const userCommands = this._getLocalIndex('user').listSync();
+    const projectCommands = projectPath ? this._getLocalIndex('project', projectPath).listSync() : [];
+    const commands = [...userCommands, ...projectCommands];
     commands.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
-
     return {
       commands,
       total: commands.length,
       userCount: userCommands.length,
-      projectCount: commands.length - userCommands.length
+      projectCount: projectCommands.length
     };
   }
 
-  /**
-   * 获取所有命令（包括远程仓库）
-   * @param {boolean} forceRefresh - 强制刷新远程缓存
-   */
+  /** 获取所有命令（包括远程仓库） */
   async listAllCommands(projectPath = null, forceRefresh = false) {
-    // 获取本地命令
     const { commands: localCommands, userCount, projectCount } = this.listCommands(projectPath);
-
-    // 获取远程命令
     let remoteCommands = [];
     try {
       remoteCommands = await this.repoScanner.listRemoteItems(forceRefresh);
-
-      // 更新安装状态
-      for (const cmd of remoteCommands) {
-        cmd.installed = this.repoScanner.isInstalled(cmd.path);
-      }
+      for (const cmd of remoteCommands) cmd.installed = this.repoScanner.isInstalled(cmd.path);
     } catch (err) {
       console.warn('[CommandsService] Failed to fetch remote commands:', err.message);
     }
-
-    // 合并列表（本地优先）
     const allCommands = [...localCommands];
-    const localKeys = new Set(localCommands.map(c =>
-      c.namespace ? `${c.namespace}/${c.name}`.toLowerCase() : c.name.toLowerCase()
-    ));
-
+    const localKeys = new Set(localCommands.map(c => c.namespace ? `${c.namespace}/${c.name}`.toLowerCase() : c.name.toLowerCase()));
     for (const remote of remoteCommands) {
       const key = remote.namespace ? `${remote.namespace}/${remote.name}`.toLowerCase() : remote.name.toLowerCase();
-      if (!localKeys.has(key)) {
-        allCommands.push(remote);
-      }
+      if (!localKeys.has(key)) allCommands.push(remote);
     }
-
-    // 排序
     allCommands.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
-
-    return {
-      commands: allCommands,
-      total: allCommands.length,
-      userCount,
-      projectCount,
-      remoteCount: remoteCommands.length
-    };
+    return { commands: allCommands, total: allCommands.length, userCount, projectCount, remoteCount: remoteCommands.length };
   }
 
-  /**
-   * 获取单个命令详情
-   */
+  /** 获取单个命令详情 */
   getCommand(name, scope, projectPath = null, namespace = null) {
     const safeName = normalizeCommandName(name);
     const safeNamespace = normalizeCommandNamespace(namespace);
     const baseDir = this._getBaseDir(scope, projectPath);
-    const { relativePath, fullPath } = this._resolveCommandPath(baseDir, safeName, safeNamespace);
-
-    if (!fs.existsSync(fullPath)) {
-      return null;
-    }
-
-    const content = fs.readFileSync(fullPath, 'utf-8');
-    const parsed = this.platform === 'gemini'
-      ? { frontmatter: {}, body: '', gemini: parseGeminiCommandToml(content) }
-      : { ...parseFrontmatter(content), gemini: null };
-
-    return {
-      name: safeName,
-      namespace: safeNamespace || null,
-      scope,
-      path: relativePath,
-      fullPath,
-      description: parsed.gemini?.description || parsed.frontmatter.description || '',
-      allowedTools: parsed.frontmatter['allowed-tools'] || '',
-      argumentHint: parsed.frontmatter['argument-hint'] || '',
-      agent: parsed.frontmatter.agent || '',
-      model: parsed.frontmatter.model || '',
-      subtask: parsed.frontmatter.subtask || '',
-      body: parsed.gemini?.body ?? parsed.body,
-      parseError: parsed.gemini?.parseError || '',
-      fullContent: content,
-      updatedAt: fs.statSync(fullPath).mtime.getTime()
-    };
+    const { relativePath } = this._resolveCommandPath(baseDir, safeName, safeNamespace);
+    const detail = this._getLocalIndex(scope, projectPath)?.getSync(relativePath);
+    if (!detail) return null;
+    return { ...detail, name: safeName, namespace: safeNamespace || null, scope, path: relativePath };
   }
 
-  /**
-   * 创建命令
-   */
+  /** 创建命令 */
   createCommand({ name, scope, projectPath, namespace, description, allowedTools, argumentHint, agent, model, subtask, body }) {
     const safeName = normalizeCommandName(name);
     const safeNamespace = normalizeCommandNamespace(namespace);
     const baseDir = this._getBaseDir(scope, projectPath);
     const { fullPath: filePath } = this._resolveCommandPath(baseDir, safeName, safeNamespace);
-    const targetDir = path.dirname(filePath);
-    ensureDir(targetDir);
-
-    // 检查是否已存在
-    if (fs.existsSync(filePath)) {
-      throw new Error(`命令 "${safeName}" 已存在`);
-    }
-
+    ensureDir(path.dirname(filePath));
+    if (fs.existsSync(filePath)) throw new Error(`命令 "${safeName}" 已存在`);
     const content = this._generateCommandContent({ description, allowedTools, argumentHint, agent, model, subtask, body });
-
     fs.writeFileSync(filePath, content, 'utf-8');
-
+    this._invalidateLocal(scope, projectPath);
     return this.getCommand(safeName, scope, projectPath, safeNamespace);
   }
 
@@ -550,9 +628,8 @@ class CommandsService {
     }
 
     const content = this._generateCommandContent({ description, allowedTools, argumentHint, agent, model, subtask, body });
-
     fs.writeFileSync(filePath, content, 'utf-8');
-
+    this._invalidateLocal(scope, projectPath);
     return this.getCommand(safeName, scope, projectPath, safeNamespace);
   }
 
@@ -584,6 +661,7 @@ class CommandsService {
       }
     }
 
+    this._invalidateLocal(scope, projectPath);
     return { success: true, message: '命令已删除' };
   }
 
@@ -645,14 +723,16 @@ class CommandsService {
    * 从远程仓库安装命令
    */
   async installFromRemote(command) {
-    return this.repoScanner.installCommand(command);
+    const result = await this.repoScanner.installCommand(command);
+    if (result && result.success !== false) this._invalidateLocal('user');
+    return result;
   }
 
-  /**
-   * 卸载命令
-   */
+  /** 卸载命令 */
   uninstallCommand(relativePath) {
-    return this.repoScanner.uninstall(relativePath);
+    const result = this.repoScanner.uninstall(relativePath);
+    if (result && result.success !== false) this._invalidateLocal('user');
+    return result;
   }
 
   // ==================== 格式转换 ====================