@adversity/coding-tool-x 2.4.1 → 2.5.0

package/src/server/api/terminal.js

@@ -9,6 +9,7 @@ const path = require('path');
 const fs = require('fs');
 
 const { ptyManager } = require('../services/pty-manager');
+const { getWebTerminalShellConfig } = require('../services/terminal-config');
 const {
   loadTerminalCommands,
   saveTerminalCommands,
@@ -171,13 +172,16 @@ router.post('/create', (req, res) => {
     // 获取启动命令
     const startCommand = getCommandForChannel(channel, sessionId, workDir);
 
+    const shellConfig = getWebTerminalShellConfig();
+
     // 创建终端
     const terminal = ptyManager.create({
       cwd: workDir,
       channel,
       sessionId,
       projectName,
-      startCommand
+      startCommand,
+      ...shellConfig
     });
 
     res.json({

package/src/server/api/workspaces.js

@@ -109,9 +109,9 @@ router.get('/check-git/*', (req, res) => {
  * GET /api/workspaces/available-projects
  * 获取所有渠道（Claude/Codex/Gemini）的项目并集
  */
-router.get('/available-projects', (req, res) => {
+router.get('/available-projects', async (req, res) => {
   try {
-    const projects = workspaceService.getAllAvailableProjects();
+    const projects = await workspaceService.getAllAvailableProjects();
     res.json({
       success: true,
       data: projects

package/src/server/index.js

@@ -109,6 +109,7 @@ async function startServer(port) {
   app.use('/api/aliases', require('./api/aliases')());
   app.use('/api/favorites', require('./api/favorites'));
   app.use('/api/ui-config', require('./api/ui-config'));
+  app.use('/api/security', require('./api/security'));
   app.use('/api/channels', require('./api/channels'));
   app.use('/api/proxy', require('./api/proxy'));
   app.use('/api/codex/proxy', require('./api/codex-proxy'));
@@ -264,7 +265,7 @@ function autoRestoreProxies() {
 }
 
 // 启动时执行健康检查
-function performStartupHealthCheck() {
+async function performStartupHealthCheck() {
   const { healthCheckAllProjects } = require('./services/health-check');
   const { getProjects } = require('./services/sessions');
 
@@ -273,7 +274,7 @@ function performStartupHealthCheck() {
 
     // 获取所有项目
     const config = loadConfig();
-    const projects = getProjects(config);
+    const projects = await getProjects(config);
 
     if (projects.length === 0) {
       console.log(chalk.gray('   未发现项目，跳过健康检查'));

package/src/server/services/config-export-service.js

@@ -8,8 +8,158 @@ const path = require('path');
 const permissionTemplatesService = require('./permission-templates-service');
 const configTemplatesService = require('./config-templates-service');
 const channelsService = require('./channels');
+const { AgentsService } = require('./agents-service');
+const { CommandsService } = require('./commands-service');
+const { RulesService } = require('./rules-service');
+const { SkillService } = require('./skill-service');
 
 const CONFIG_VERSION = '1.0.0';
+const SKILL_FILE_ENCODING = 'base64';
+const SKILL_IGNORE_DIRS = new Set(['.git']);
+const SKILL_IGNORE_FILES = new Set(['.DS_Store']);
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function resolveSafePath(baseDir, relativePath) {
+  if (!relativePath || typeof relativePath !== 'string') return null;
+  const normalized = path.normalize(relativePath);
+  if (path.isAbsolute(normalized)) return null;
+  const resolved = path.resolve(baseDir, normalized);
+  const relative = path.relative(baseDir, resolved);
+  if (relative.startsWith('..') || path.isAbsolute(relative)) return null;
+  return resolved;
+}
+
+function buildAgentContent(agent) {
+  const lines = ['---'];
+  if (agent.name) lines.push(`name: ${agent.name}`);
+  if (agent.description) lines.push(`description: "${agent.description}"`);
+  if (agent.tools) lines.push(`tools: ${agent.tools}`);
+  if (agent.model) lines.push(`model: ${agent.model}`);
+  if (agent.permissionMode) lines.push(`permissionMode: ${agent.permissionMode}`);
+  if (agent.skills) lines.push(`skills: ${agent.skills}`);
+  lines.push('---');
+  const body = agent.systemPrompt || '';
+  return `${lines.join('\n')}\n\n${body}`;
+}
+
+function buildCommandContent(command) {
+  const frontmatter = {};
+  if (command.description) frontmatter.description = command.description;
+  if (command.allowedTools) frontmatter['allowed-tools'] = command.allowedTools;
+  if (command.argumentHint) frontmatter['argument-hint'] = command.argumentHint;
+
+  const lines = [];
+  if (Object.keys(frontmatter).length > 0) {
+    lines.push('---');
+    if (frontmatter.description) {
+      lines.push(`description: "${frontmatter.description}"`);
+    }
+    if (frontmatter['allowed-tools']) {
+      lines.push(`allowed-tools: ${frontmatter['allowed-tools']}`);
+    }
+    if (frontmatter['argument-hint']) {
+      lines.push(`argument-hint: ${frontmatter['argument-hint']}`);
+    }
+    lines.push('---');
+    lines.push('');
+  }
+
+  const body = command.body || '';
+  return `${lines.join('\n')}${body}`;
+}
+
+function buildRuleContent(rule) {
+  const lines = [];
+  if (rule.paths) {
+    lines.push('---');
+    lines.push(`paths: ${rule.paths}`);
+    lines.push('---');
+    lines.push('');
+  }
+  const body = rule.body || '';
+  return `${lines.join('\n')}${body}`;
+}
+
+function collectSkillFiles(baseDir) {
+  const files = [];
+  const stack = [baseDir];
+
+  while (stack.length > 0) {
+    const currentDir = stack.pop();
+    let entries = [];
+    try {
+      entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    } catch (err) {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (SKILL_IGNORE_DIRS.has(entry.name)) {
+          continue;
+        }
+        stack.push(path.join(currentDir, entry.name));
+      } else if (entry.isFile()) {
+        if (SKILL_IGNORE_FILES.has(entry.name)) {
+          continue;
+        }
+        const fullPath = path.join(currentDir, entry.name);
+        const relativePath = path.relative(baseDir, fullPath);
+        try {
+          const content = fs.readFileSync(fullPath);
+          files.push({
+            path: relativePath,
+            encoding: SKILL_FILE_ENCODING,
+            content: content.toString(SKILL_FILE_ENCODING)
+          });
+        } catch (err) {
+          continue;
+        }
+      }
+    }
+  }
+
+  files.sort((a, b) => a.path.localeCompare(b.path));
+  return files;
+}
+
+function exportSkillsSnapshot() {
+  const skillService = new SkillService();
+  const installedSkills = skillService.getInstalledSkills();
+  const baseDir = skillService.installDir;
+
+  return installedSkills.map((skill) => {
+    const directory = skill.directory;
+    const skillDir = resolveSafePath(baseDir, directory);
+    if (!skillDir || !fs.existsSync(skillDir)) {
+      return null;
+    }
+    return {
+      directory,
+      name: skill.name || directory,
+      description: skill.description || '',
+      files: collectSkillFiles(skillDir)
+    };
+  }).filter(Boolean);
+}
+
+function writeTextFile(baseDir, relativePath, content, overwrite) {
+  if (!content && content !== '') {
+    return 'failed';
+  }
+  const targetPath = resolveSafePath(baseDir, relativePath);
+  if (!targetPath) return 'failed';
+  if (fs.existsSync(targetPath) && !overwrite) return 'skipped';
+
+  ensureDir(path.dirname(targetPath));
+  fs.writeFileSync(targetPath, content, 'utf8');
+  return 'success';
+}
 
 /**
  * 导出所有配置为JSON
@@ -38,20 +188,49 @@ function exportAllConfigs() {
     const favorites = favoritesService.loadFavorites();
 
     // 获取 Agents 配置
-    const agentsService = require('./agents-service');
-    const agents = agentsService.getAllAgents();
+    const agentsService = new AgentsService();
+    const { agents: rawAgents } = agentsService.listAgents();
+    const agents = rawAgents.map(agent => ({
+      fileName: agent.fileName,
+      name: agent.name,
+      description: agent.description,
+      tools: agent.tools,
+      model: agent.model,
+      permissionMode: agent.permissionMode,
+      skills: agent.skills,
+      path: agent.path,
+      systemPrompt: agent.systemPrompt,
+      fullContent: agent.fullContent
+    }));
 
     // 获取 Skills 配置
-    const skillService = require('./skill-service');
-    const skills = skillService.getAllSkills();
+    const skills = exportSkillsSnapshot();
 
     // 获取 Commands 配置
-    const commandsService = require('./commands-service');
-    const commands = commandsService.getAllCommands();
+    const commandsService = new CommandsService();
+    const { commands: rawCommands } = commandsService.listCommands();
+    const commands = rawCommands.map(command => ({
+      name: command.name,
+      namespace: command.namespace,
+      description: command.description,
+      allowedTools: command.allowedTools,
+      argumentHint: command.argumentHint,
+      path: command.path,
+      body: command.body,
+      fullContent: command.fullContent
+    }));
 
     // 获取 Rules 配置
-    const rulesService = require('./rules-service');
-    const rules = rulesService.getAllRules();
+    const rulesService = new RulesService();
+    const { rules: rawRules } = rulesService.listRules();
+    const rules = rawRules.map(rule => ({
+      fileName: rule.fileName,
+      directory: rule.directory,
+      paths: rule.paths,
+      path: rule.path,
+      body: rule.body,
+      fullContent: rule.fullContent
+    }));
 
     // 获取 MCP 配置
     const mcpService = require('./mcp-service');
@@ -251,15 +430,24 @@ function importConfigs(importData, options = {}) {
     }
 
     // 导入 Agents
-    if (agents && agents.length > 0 && overwrite) {
+    if (agents && agents.length > 0) {
       try {
-        const agentsService = require('./agents-service');
+        const agentsService = new AgentsService();
+        const baseDir = agentsService.userAgentsDir;
+
         for (const agent of agents) {
-          try {
-            agentsService.saveAgent(agent);
+          const relativePath = agent.path || agent.fileName || agent.name;
+          const filePath = relativePath && relativePath.endsWith('.md')
+            ? relativePath
+            : (relativePath ? `${relativePath}.md` : null);
+          const content = agent.fullContent || agent.content || buildAgentContent(agent);
+
+          const status = filePath ? writeTextFile(baseDir, filePath, content, overwrite) : 'failed';
+          if (status === 'success') {
             results.agents.success++;
-          } catch (err) {
-            console.error(`[ConfigImport] 导入 Agent 失败: ${agent.name}`, err);
+          } else if (status === 'skipped') {
+            results.agents.skipped++;
+          } else {
             results.agents.failed++;
           }
         }
@@ -269,16 +457,55 @@ function importConfigs(importData, options = {}) {
     }
 
     // 导入 Skills
-    if (skills && skills.length > 0 && overwrite) {
+    if (skills && skills.length > 0) {
       try {
-        const skillService = require('./skill-service');
+        const skillService = new SkillService();
+        const baseDir = skillService.installDir;
+        ensureDir(baseDir);
+
         for (const skill of skills) {
-          try {
-            skillService.saveSkill(skill);
-            results.skills.success++;
-          } catch (err) {
-            console.error(`[ConfigImport] 导入 Skill 失败: ${skill.name}`, err);
+          const directory = skill.directory;
+          const skillDir = resolveSafePath(baseDir, directory);
+          if (!skillDir) {
+            results.skills.failed++;
+            continue;
+          }
+
+          if (fs.existsSync(skillDir)) {
+            if (!overwrite) {
+              results.skills.skipped++;
+              continue;
+            }
+            fs.rmSync(skillDir, { recursive: true, force: true });
+          }
+
+          ensureDir(skillDir);
+          const files = Array.isArray(skill.files) ? skill.files : [];
+          let failed = false;
+
+          for (const file of files) {
+            const filePath = resolveSafePath(skillDir, file.path);
+            if (!filePath) {
+              failed = true;
+              break;
+            }
+            ensureDir(path.dirname(filePath));
+            try {
+              if (file.encoding === SKILL_FILE_ENCODING) {
+                fs.writeFileSync(filePath, Buffer.from(file.content || '', SKILL_FILE_ENCODING));
+              } else {
+                fs.writeFileSync(filePath, file.content || '', file.encoding || 'utf8');
+              }
+            } catch (err) {
+              failed = true;
+              break;
+            }
+          }
+
+          if (failed || files.length === 0) {
             results.skills.failed++;
+          } else {
+            results.skills.success++;
           }
         }
       } catch (err) {
@@ -287,15 +514,25 @@ function importConfigs(importData, options = {}) {
     }
 
     // 导入 Commands
-    if (commands && commands.length > 0 && overwrite) {
+    if (commands && commands.length > 0) {
       try {
-        const commandsService = require('./commands-service');
+        const commandsService = new CommandsService();
+        const baseDir = commandsService.userCommandsDir;
+
         for (const command of commands) {
-          try {
-            commandsService.saveCommand(command);
+          const relativePath = command.path || (
+            command.namespace
+              ? path.join(command.namespace, `${command.name}.md`)
+              : `${command.name}.md`
+          );
+          const content = command.fullContent || command.content || buildCommandContent(command);
+
+          const status = relativePath ? writeTextFile(baseDir, relativePath, content, overwrite) : 'failed';
+          if (status === 'success') {
             results.commands.success++;
-          } catch (err) {
-            console.error(`[ConfigImport] 导入 Command 失败: ${command.name}`, err);
+          } else if (status === 'skipped') {
+            results.commands.skipped++;
+          } else {
             results.commands.failed++;
           }
         }
@@ -305,15 +542,25 @@ function importConfigs(importData, options = {}) {
     }
 
     // 导入 Rules
-    if (rules && rules.length > 0 && overwrite) {
+    if (rules && rules.length > 0) {
       try {
-        const rulesService = require('./rules-service');
+        const rulesService = new RulesService();
+        const baseDir = rulesService.userRulesDir;
+
         for (const rule of rules) {
-          try {
-            rulesService.saveRule(rule);
+          const relativePath = rule.path || (
+            rule.directory
+              ? path.join(rule.directory, `${rule.fileName || rule.name}.md`)
+              : `${rule.fileName || rule.name}.md`
+          );
+          const content = rule.fullContent || rule.content || buildRuleContent(rule);
+
+          const status = relativePath ? writeTextFile(baseDir, relativePath, content, overwrite) : 'failed';
+          if (status === 'success') {
             results.rules.success++;
-          } catch (err) {
-            console.error(`[ConfigImport] 导入 Rule 失败: ${rule.name}`, err);
+          } else if (status === 'skipped') {
+            results.rules.skipped++;
+          } else {
             results.rules.failed++;
           }
         }