coding-tool-x 3.5.7 → 3.5.8

package/src/config/paths.js

@@ -28,6 +28,9 @@ const REPOS_SKILLS_DIR = path.join(REPOS_DIR, 'skills');
 const REPOS_PLUGINS_DIR = path.join(REPOS_DIR, 'plugins');
 const LOCAL_DIR = path.join(STORAGE_DIR, 'local');
 const LOCAL_SKILLS_DIR = path.join(LOCAL_DIR, 'skills');
+const LOCAL_COMMANDS_DIR = path.join(LOCAL_DIR, 'commands');
+const LOCAL_AGENTS_DIR = path.join(LOCAL_DIR, 'agents');
+const LOCAL_PLUGINS_DIR = path.join(LOCAL_DIR, 'plugins');
 const REQUESTS_DIR = path.join(STORAGE_DIR, 'requests');
 const BACKUPS_DIR = path.join(STORAGE_DIR, 'backups');
 const SCRIPTS_DIR = path.join(STORAGE_DIR, 'scripts');
@@ -39,8 +42,8 @@ const LEGACY_STATS_DIR = path.join(LEGACY_DIR, 'stats');
 
 // 旧目录（升级时自动合并到 ~/.cc-tool）
 const LEGACY_BASE_DIRS = [
-  path.join(HOME_DIR, '.claude', 'ctx'),
-  path.join(HOME_DIR, '.claude', 'cc-tool')
+  joinNativeBasePath(HOME_DIR, '.claude', 'ctx'),
+  joinNativeBasePath(HOME_DIR, '.claude', 'cc-tool')
 ];
 
 let migrationChecked = false;
@@ -464,6 +467,19 @@ const PATHS = {
     gemini: path.join(LOCAL_SKILLS_DIR, 'gemini'),
     opencode: path.join(LOCAL_SKILLS_DIR, 'opencode')
   },
+  localCommands: {
+    claude: path.join(LOCAL_COMMANDS_DIR, 'claude'),
+    opencode: path.join(LOCAL_COMMANDS_DIR, 'opencode')
+  },
+  localAgents: {
+    claude: path.join(LOCAL_AGENTS_DIR, 'claude'),
+    codex: path.join(LOCAL_AGENTS_DIR, 'codex'),
+    opencode: path.join(LOCAL_AGENTS_DIR, 'opencode')
+  },
+  localPlugins: {
+    claude: path.join(LOCAL_PLUGINS_DIR, 'claude'),
+    opencode: path.join(LOCAL_PLUGINS_DIR, 'opencode')
+  },
   skillRepos: {
     claude: path.join(REPOS_SKILLS_DIR, 'claude.json'),
     codex: path.join(REPOS_SKILLS_DIR, 'codex.json'),
@@ -486,7 +502,7 @@ const PATHS = {
   },
 
   // 原生路径兼容
-  skills: path.join(HOME_DIR, '.claude', 'skills'),
+  skills: getNativePlatformSkillsDir('claude'),
 
   // 旧版本遗留文件搬迁目标
   legacy: {
@@ -715,15 +731,15 @@ function pickExistingDir(candidates, fallback) {
 }
 
 function getClaudeConfigDir() {
-  return resolveExistingEnvPath(process.env.CLAUDE_CONFIG_DIR) || path.join(HOME_DIR, '.claude');
+  return resolveExistingEnvPath(process.env.CLAUDE_CONFIG_DIR) || joinNativeBasePath(HOME_DIR, '.claude');
 }
 
 function getCodexDir() {
-  return resolveExistingEnvPath(process.env.CODEX_HOME) || path.join(HOME_DIR, '.codex');
+  return resolveExistingEnvPath(process.env.CODEX_HOME) || joinNativeBasePath(HOME_DIR, '.codex');
 }
 
 function getGeminiDir() {
-  return path.join(HOME_DIR, '.gemini');
+  return joinNativeBasePath(HOME_DIR, '.gemini');
 }
 
 function getOpenCodeDataDir() {
@@ -762,49 +778,151 @@ function getOpenCodeConfigDir() {
   return preferredDir;
 }
 
+function isWindowsAbsolutePath(value = '') {
+  return /^[a-zA-Z]:[\\/]/.test(String(value || ''));
+}
+
+function isNativeAbsolutePath(value = '') {
+  return path.isAbsolute(String(value || '')) || isWindowsAbsolutePath(value);
+}
+
+function joinNativeBasePath(baseDir, ...segments) {
+  const base = String(baseDir || '');
+  const pathModule = isWindowsAbsolutePath(base) ? path.win32 : path;
+  return pathModule.join(base, ...segments);
+}
+
+function resolveNativeBasePath(baseDir, ...segments) {
+  const base = String(baseDir || '');
+  const pathModule = isWindowsAbsolutePath(base) ? path.win32 : path;
+  return pathModule.resolve(base, ...segments);
+}
+
+function getNativePathDir(filePath = '') {
+  const target = String(filePath || '');
+  const pathModule = isWindowsAbsolutePath(target) ? path.win32 : path;
+  return pathModule.dirname(target);
+}
+
+function getNativePlatformDir(platform) {
+  switch (platform) {
+    case 'claude':
+      return getClaudeConfigDir();
+    case 'codex':
+      return getCodexDir();
+    case 'gemini':
+      return getGeminiDir();
+    case 'opencode':
+      return getOpenCodeConfigDir();
+    default:
+      return '';
+  }
+}
+
+function getNativePlatformSubPath(platform, ...segments) {
+  const baseDir = getNativePlatformDir(platform);
+  return baseDir ? joinNativeBasePath(baseDir, ...segments) : '';
+}
+
+function getNativePlatformSkillsDir(platform) {
+  return getNativePlatformSubPath(platform, 'skills');
+}
+
+function getNativePlatformPromptPath(platform) {
+  if (!getNativePlatformDir(platform)) {
+    return '';
+  }
+
+  switch (platform) {
+    case 'claude':
+      return getNativePlatformSubPath(platform, 'CLAUDE.md');
+    case 'codex':
+      return getNativePlatformSubPath(platform, 'AGENTS.md');
+    case 'gemini':
+      return getNativePlatformSubPath(platform, 'GEMINI.md');
+    case 'opencode':
+      return getNativePlatformSubPath(platform, 'AGENTS.md');
+    default:
+      return '';
+  }
+}
+
+const CLAUDE_NATIVE_DIR = getNativePlatformDir('claude');
+const CODEX_NATIVE_DIR = getNativePlatformDir('codex');
+const GEMINI_NATIVE_DIR = getNativePlatformDir('gemini');
+const OPENCODE_CONFIG_DIR = getNativePlatformDir('opencode');
+const OPENCODE_DATA_DIR = getOpenCodeDataDir();
+
 // 工具特定的原生配置路径（不改变）
 const NATIVE_PATHS = {
   // Claude Code 原生配置
   claude: {
-    dir: getClaudeConfigDir(),
-    settings: path.join(getClaudeConfigDir(), 'settings.json'),
-    settingsBackup: path.join(getClaudeConfigDir(), 'settings.json.cc-tool-backup'),
-    projects: path.join(getClaudeConfigDir(), 'projects'),
-    credentials: path.join(getClaudeConfigDir(), '.credentials.json')
+    dir: CLAUDE_NATIVE_DIR,
+    settings: joinNativeBasePath(CLAUDE_NATIVE_DIR, 'settings.json'),
+    settingsBackup: joinNativeBasePath(CLAUDE_NATIVE_DIR, 'settings.json.cc-tool-backup'),
+    projects: joinNativeBasePath(CLAUDE_NATIVE_DIR, 'projects'),
+    commands: joinNativeBasePath(CLAUDE_NATIVE_DIR, 'commands'),
+    agents: joinNativeBasePath(CLAUDE_NATIVE_DIR, 'agents'),
+    plugins: joinNativeBasePath(CLAUDE_NATIVE_DIR, 'plugins'),
+    installedPlugins: joinNativeBasePath(CLAUDE_NATIVE_DIR, 'plugins', 'installed_plugins.json'),
+    pluginMarketplaces: joinNativeBasePath(CLAUDE_NATIVE_DIR, 'plugins', 'known_marketplaces.json'),
+    credentials: joinNativeBasePath(CLAUDE_NATIVE_DIR, '.credentials.json'),
+    skills: getNativePlatformSkillsDir('claude'),
+    prompt: getNativePlatformPromptPath('claude')
   },
 
   // Codex 原生配置
   codex: {
-    dir: getCodexDir(),
-    config: path.join(getCodexDir(), 'config.toml'),
-    configBackup: path.join(getCodexDir(), 'config.toml.cc-tool-backup'),
-    auth: path.join(getCodexDir(), 'auth.json'),
-    authBackup: path.join(getCodexDir(), 'auth.json.cc-tool-backup'),
-    sessions: path.join(getCodexDir(), 'sessions')
+    dir: CODEX_NATIVE_DIR,
+    config: joinNativeBasePath(CODEX_NATIVE_DIR, 'config.toml'),
+    configBackup: joinNativeBasePath(CODEX_NATIVE_DIR, 'config.toml.cc-tool-backup'),
+    auth: joinNativeBasePath(CODEX_NATIVE_DIR, 'auth.json'),
+    authBackup: joinNativeBasePath(CODEX_NATIVE_DIR, 'auth.json.cc-tool-backup'),
+    sessions: joinNativeBasePath(CODEX_NATIVE_DIR, 'sessions'),
+    projects: joinNativeBasePath(CODEX_NATIVE_DIR, 'projects'),
+    agents: joinNativeBasePath(CODEX_NATIVE_DIR, 'agents'),
+    prompts: joinNativeBasePath(CODEX_NATIVE_DIR, 'prompts'),
+    skills: getNativePlatformSkillsDir('codex'),
+    prompt: getNativePlatformPromptPath('codex')
   },
 
   // Gemini 原生配置
   gemini: {
-    dir: getGeminiDir(),
-    env: path.join(getGeminiDir(), '.env'),
-    envBackup: path.join(getGeminiDir(), '.env.cc-tool-backup'),
-    tmp: path.join(getGeminiDir(), 'tmp'),
-    settings: path.join(getGeminiDir(), 'settings.json'),
-    settingsBackup: path.join(getGeminiDir(), 'settings.json.cc-tool-backup'),
-    googleAccounts: path.join(getGeminiDir(), 'google_accounts.json'),
-    oauthCredentialsLegacy: path.join(getGeminiDir(), 'oauth_creds.json'),
-    oauthCredentialsEncrypted: path.join(getGeminiDir(), 'mcp-oauth-tokens-v2.json')
+    dir: GEMINI_NATIVE_DIR,
+    env: joinNativeBasePath(GEMINI_NATIVE_DIR, '.env'),
+    envBackup: joinNativeBasePath(GEMINI_NATIVE_DIR, '.env.cc-tool-backup'),
+    tmp: joinNativeBasePath(GEMINI_NATIVE_DIR, 'tmp'),
+    settings: joinNativeBasePath(GEMINI_NATIVE_DIR, 'settings.json'),
+    settingsBackup: joinNativeBasePath(GEMINI_NATIVE_DIR, 'settings.json.cc-tool-backup'),
+    projects: joinNativeBasePath(GEMINI_NATIVE_DIR, 'projects'),
+    googleAccounts: joinNativeBasePath(GEMINI_NATIVE_DIR, 'google_accounts.json'),
+    oauthCredentialsLegacy: joinNativeBasePath(GEMINI_NATIVE_DIR, 'oauth_creds.json'),
+    oauthCredentialsEncrypted: joinNativeBasePath(GEMINI_NATIVE_DIR, 'mcp-oauth-tokens-v2.json'),
+    skills: getNativePlatformSkillsDir('gemini'),
+    prompt: getNativePlatformPromptPath('gemini')
   },
 
   // OpenCode 原生配置
   opencode: {
-    data: getOpenCodeDataDir(),
-    config: getOpenCodeConfigDir(),
-    sessions: path.join(getOpenCodeDataDir(), 'storage', 'session'),
-    projects: path.join(getOpenCodeDataDir(), 'storage', 'project'),
-    messages: path.join(getOpenCodeDataDir(), 'storage', 'message'),
-    log: path.join(getOpenCodeDataDir(), 'log'),
-    auth: path.join(getOpenCodeDataDir(), 'auth.json')
+    data: OPENCODE_DATA_DIR,
+    config: OPENCODE_CONFIG_DIR,
+    sessions: joinNativeBasePath(OPENCODE_DATA_DIR, 'storage', 'session'),
+    projects: joinNativeBasePath(OPENCODE_DATA_DIR, 'storage', 'project'),
+    messages: joinNativeBasePath(OPENCODE_DATA_DIR, 'storage', 'message'),
+    log: joinNativeBasePath(OPENCODE_DATA_DIR, 'log'),
+    auth: joinNativeBasePath(OPENCODE_DATA_DIR, 'auth.json'),
+    commands: joinNativeBasePath(OPENCODE_CONFIG_DIR, 'commands'),
+    commandsLegacy: joinNativeBasePath(OPENCODE_CONFIG_DIR, 'command'),
+    agents: joinNativeBasePath(OPENCODE_CONFIG_DIR, 'agents'),
+    agentsLegacy: joinNativeBasePath(OPENCODE_CONFIG_DIR, 'agent'),
+    plugins: joinNativeBasePath(OPENCODE_CONFIG_DIR, 'plugins'),
+    pluginsLegacy: joinNativeBasePath(OPENCODE_CONFIG_DIR, 'plugin'),
+    pluginsConfig: joinNativeBasePath(OPENCODE_CONFIG_DIR, 'plugins-config'),
+    configJsonc: joinNativeBasePath(OPENCODE_CONFIG_DIR, 'opencode.jsonc'),
+    configJson: joinNativeBasePath(OPENCODE_CONFIG_DIR, 'opencode.json'),
+    configLegacy: joinNativeBasePath(OPENCODE_CONFIG_DIR, 'config.json'),
+    skills: getNativePlatformSkillsDir('opencode'),
+    prompt: getNativePlatformPromptPath('opencode')
   }
 };
 
@@ -823,6 +941,15 @@ module.exports = {
   getClaudeConfigDir,
   getCodexDir,
   getGeminiDir,
+  isWindowsAbsolutePath,
+  isNativeAbsolutePath,
+  joinNativeBasePath,
+  resolveNativeBasePath,
+  getNativePathDir,
+  getNativePlatformDir,
+  getNativePlatformSubPath,
+  getNativePlatformSkillsDir,
+  getNativePlatformPromptPath,
   getOpenCodeDataDir,
   getOpenCodeConfigDir
 };

package/src/server/api/agents.js

@@ -228,7 +228,7 @@ router.use((req, res, next) => {
 router.get('/', (req, res) => {
   try {
     const { platform, service } = getAgentsService(req);
-    const { projectPath } = req.query;
+    const { projectPath, refresh } = req.query;
     const normalizedProjectPath = normalizeOptionalProjectPath(projectPath);
     if (normalizedProjectPath.error) {
       return res.status(400).json({
@@ -236,7 +236,10 @@ router.get('/', (req, res) => {
         message: normalizedProjectPath.error
       });
     }
-    const result = service.listAgents(normalizedProjectPath.projectPath);
+    const forceRefresh = refresh === '1';
+    const result = service.listAgents(normalizedProjectPath.projectPath, {
+      syncManagedLocalAgents: forceRefresh
+    });
 
     res.json({
       success: true,
@@ -775,6 +778,53 @@ router.post('/install', async (req, res) => {
   }
 });
 
+/**
+ * 安装本地托管代理
+ * POST /api/agents/install-local
+ * Body: { fileName }
+ */
+router.post('/install-local', (req, res) => {
+  try {
+    const { platform, service } = getAgentsService(req);
+    if (isCodexRepoOperationUnsupported(platform)) {
+      return res.status(400).json({
+        success: false,
+        message: 'Codex 平台暂不支持本地托管代理安装'
+      });
+    }
+
+    const { fileName } = req.body;
+    if (!fileName) {
+      return res.status(400).json({
+        success: false,
+        message: 'Missing fileName'
+      });
+    }
+
+    const fileNameError = validateAgentFileName(fileName);
+    if (fileNameError) {
+      return res.status(400).json({
+        success: false,
+        message: fileNameError
+      });
+    }
+
+    const result = service.installLocalAgent(fileName);
+
+    res.json({
+      success: true,
+      platform,
+      ...result
+    });
+  } catch (err) {
+    console.error('[Agents API] Install local agent error:', err);
+    res.status(500).json({
+      success: false,
+      message: err.message
+    });
+  }
+});
+
 /**
  * 卸载代理
  * POST /api/agents/uninstall

package/src/server/api/commands.js

@@ -35,8 +35,11 @@ function getCommandsService(req) {
 router.get('/', (req, res) => {
   try {
     const { platform, service } = getCommandsService(req);
-    const { projectPath } = req.query;
-    const result = service.listCommands(projectPath || null);
+    const { projectPath, refresh } = req.query;
+    const forceRefresh = refresh === '1';
+    const result = service.listCommands(projectPath || null, {
+      syncManagedLocalCommands: forceRefresh
+    });
 
     res.json({
       success: true,
@@ -446,6 +449,39 @@ router.post('/install', async (req, res) => {
   }
 });
 
+/**
+ * 安装本地托管命令
+ * POST /api/commands/install-local
+ * Body: { path }
+ */
+router.post('/install-local', (req, res) => {
+  try {
+    const { platform, service } = getCommandsService(req);
+    const { path } = req.body;
+
+    if (!path) {
+      return res.status(400).json({
+        success: false,
+        message: 'Missing path'
+      });
+    }
+
+    const result = service.installLocalCommand(path);
+
+    res.json({
+      success: true,
+      platform,
+      ...result
+    });
+  } catch (err) {
+    console.error('[Commands API] Install local command error:', err);
+    res.status(500).json({
+      success: false,
+      message: err.message
+    });
+  }
+});
+
 /**
  * 卸载命令
  * POST /api/commands/uninstall

package/src/server/api/plugins.js

@@ -88,7 +88,10 @@ function sanitizeRepos(service, repos = []) {
 router.get('/', (req, res) => {
   try {
     const { platform, service } = getPluginsService(req);
-    const result = service.listPlugins();
+    const forceRefresh = req.query.refresh === '1';
+    const result = service.listPlugins({
+      syncManagedLocalPlugins: forceRefresh
+    });
 
     res.json({
       success: true,
@@ -189,6 +192,46 @@ router.post('/install', async (req, res) => {
   }
 });
 
+/**
+ * 安装本地托管插件
+ * POST /api/plugins/install-local
+ * Body: { name }
+ */
+router.post('/install-local', (req, res) => {
+  try {
+    const { platform, service } = getPluginsService(req);
+    const { name } = req.body;
+
+    if (!name) {
+      return res.status(400).json({
+        success: false,
+        message: 'name is required'
+      });
+    }
+
+    const result = service.installLocalPlugin(name);
+    if (!result.success) {
+      return res.status(400).json({
+        success: false,
+        message: result.error || result.message || 'Install failed'
+      });
+    }
+
+    res.json({
+      success: true,
+      platform,
+      plugin: result.plugin,
+      message: result.message || `Plugin "${result.plugin?.name || name}" installed successfully`
+    });
+  } catch (err) {
+    console.error('[Plugins API] Install local plugin error:', err);
+    res.status(500).json({
+      success: false,
+      message: err.message
+    });
+  }
+});
+
 // ==================== 仓库管理 API ====================
 
 /**
@@ -440,6 +483,66 @@ router.post('/sync', async (req, res) => {
   }
 });
 
+/**
+ * 获取插件文件列表
+ * GET /api/plugins/:name/files
+ */
+router.get('/:name/files', async (req, res) => {
+  try {
+    const { platform, service } = getPluginsService(req);
+    const { name } = req.params;
+    const pluginInfo = extractPluginQueryInfo(name, req.query);
+    const result = await service.getPluginFiles(pluginInfo);
+
+    res.json({
+      success: true,
+      platform,
+      ...result
+    });
+  } catch (err) {
+    console.error('[Plugins API] Get plugin files error:', err);
+    res.status(500).json({
+      success: false,
+      message: err.message,
+      files: []
+    });
+  }
+});
+
+/**
+ * 获取插件单个文件内容
+ * GET /api/plugins/:name/file/*
+ */
+router.get('/:name/file/*', async (req, res) => {
+  try {
+    const { platform, service } = getPluginsService(req);
+    const { name } = req.params;
+    const filePath = req.params[0];
+
+    if (!filePath) {
+      return res.status(400).json({
+        success: false,
+        message: '请指定文件路径'
+      });
+    }
+
+    const pluginInfo = extractPluginQueryInfo(name, req.query);
+    const result = await service.getPluginFileContent(pluginInfo, filePath);
+
+    res.json({
+      success: true,
+      platform,
+      ...result
+    });
+  } catch (err) {
+    console.error('[Plugins API] Get plugin file content error:', err);
+    res.status(500).json({
+      success: false,
+      message: err.message
+    });
+  }
+});
+
 /**
  * 获取插件 README
  * GET /api/plugins/:name/readme

package/src/server/api/sessions.js

@@ -7,7 +7,7 @@ const { getSessionsForProject, deleteSession, forkSession, saveSessionOrder, par
 const { loadAliases } = require('../services/alias');
 const { broadcastLog } = require('../websocket-server');
 const { buildLaunchCommand } = require('../services/session-launch-command');
-const { NATIVE_PATHS } = require('../../config/paths');
+const { NATIVE_PATHS, joinNativeBasePath } = require('../../config/paths');
 const CLAUDE_PROJECTS_DIR = NATIVE_PATHS.claude.projects;
 
 module.exports = (config) => {
@@ -171,13 +171,13 @@ module.exports = (config) => {
         const year = now.getFullYear();
         const month = String(now.getMonth() + 1).padStart(2, '0');
         const day = String(now.getDate()).padStart(2, '0');
-        sessionDir = path.join(NATIVE_PATHS.codex.sessions, String(year), month, day);
-        sessionFile = path.join(sessionDir, `${newSessionId}.jsonl`);
+        sessionDir = joinNativeBasePath(NATIVE_PATHS.codex.sessions, String(year), month, day);
+        sessionFile = joinNativeBasePath(sessionDir, `${newSessionId}.jsonl`);
       } else if (toolType === 'gemini') {
         // Gemini: ~/.gemini/tmp/{hash}/chats/{sessionId}.json
         const pathHash = crypto.createHash('sha256').update(fullPath).digest('hex');
-        sessionDir = path.join(NATIVE_PATHS.gemini.tmp, pathHash, 'chats');
-        sessionFile = path.join(sessionDir, `${newSessionId}.json`);
+        sessionDir = joinNativeBasePath(NATIVE_PATHS.gemini.tmp, pathHash, 'chats');
+        sessionFile = joinNativeBasePath(sessionDir, `${newSessionId}.json`);
       } else {
         return res.status(400).json({ error: 'Invalid toolType. Must be claude, codex, or gemini' });
       }