claude-code-workflow 6.3.18 → 6.3.20

package/ccw/src/core/routes/claude-routes.ts

@@ -1,22 +1,11 @@
-// @ts-nocheck
 /**
  * CLAUDE.md Routes Module
  * Handles all CLAUDE.md memory rules management endpoints
  */
-import type { IncomingMessage, ServerResponse } from 'http';
 import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, unlinkSync, mkdirSync } from 'fs';
-import { join, relative } from 'path';
+import { dirname, join, relative } from 'path';
 import { homedir } from 'os';
-
-export interface RouteContext {
-  pathname: string;
-  url: URL;
-  req: IncomingMessage;
-  res: ServerResponse;
-  initialPath: string;
-  handlePostRequest: (req: IncomingMessage, res: ServerResponse, handler: (body: unknown) => Promise<any>) => void;
-  broadcastToClients: (data: unknown) => void;
-}
+import type { RouteContext } from './types.js';
 
 interface ClaudeFile {
   id: string;
@@ -498,7 +487,7 @@ function createNewClaudeFile(level: 'user' | 'project' | 'module', template: str
     }
 
     // Ensure directory exists
-    const dir = filePath.substring(0, filePath.lastIndexOf('/') || filePath.lastIndexOf('\\'));
+    const dir = dirname(filePath);
     if (!existsSync(dir)) {
       mkdirSync(dir, { recursive: true });
     }
@@ -567,8 +556,9 @@ export async function handleClaudeRoutes(ctx: RouteContext): Promise<boolean> {
       }
 
       try {
-        // Import CLI executor
+        // Import CLI executor and content formatter
         const { executeCliTool } = await import('../../tools/cli-executor.js');
+        const { SmartContentFormatter } = await import('../../tools/cli-output-converter.js');
 
         // Determine file path based on level
         let filePath: string;
@@ -601,6 +591,33 @@ export async function handleClaudeRoutes(ctx: RouteContext): Promise<boolean> {
 
         // Execute CLI tool
         const syncId = `claude-sync-${level}-${Date.now()}`;
+
+        // Broadcast CLI_EXECUTION_STARTED event
+        broadcastToClients({
+          type: 'CLI_EXECUTION_STARTED',
+          payload: {
+            executionId: syncId,
+            tool: tool === 'qwen' ? 'qwen' : 'gemini',
+            mode: 'analysis',
+            category: 'internal',
+            context: 'claude-sync',
+            level
+          }
+        });
+
+        // Create onOutput callback for real-time streaming
+        const onOutput = (chunk: { type: string; data: string }) => {
+          broadcastToClients({
+            type: 'CLI_OUTPUT',
+            payload: {
+              executionId: syncId,
+              chunkType: chunk.type,
+              data: chunk.data
+            }
+          });
+        };
+
+        const startTime = Date.now();
         const result = await executeCliTool({
           tool: tool === 'qwen' ? 'qwen' : 'gemini',
           prompt: cliPrompt,
@@ -611,20 +628,45 @@ export async function handleClaudeRoutes(ctx: RouteContext): Promise<boolean> {
           stream: false,
           category: 'internal',
           id: syncId
+        }, (unit) => {
+          // CliOutputUnit handler: use SmartContentFormatter for intelligent formatting (never returns null)
+          const content = SmartContentFormatter.format(unit.content, unit.type);
+          broadcastToClients({
+            type: 'CLI_OUTPUT',
+            payload: {
+              executionId: syncId,
+              chunkType: unit.type,
+              data: content
+            }
+          });
+        });
+
+        // Broadcast CLI_EXECUTION_COMPLETED event
+        broadcastToClients({
+          type: 'CLI_EXECUTION_COMPLETED',
+          payload: {
+            executionId: syncId,
+            success: result.success,
+            status: result.execution?.status || (result.success ? 'success' : 'error'),
+            duration_ms: Date.now() - startTime
+          }
         });
 
-        if (!result.success || !result.execution?.output) {
+        if (!result.success) {
           return {
             error: 'CLI execution failed',
-            details: result.execution?.error || 'No output received',
+            details: result.stderr || result.execution?.output?.stderr || 'No output received',
             status: 500
           };
         }
 
-        // Extract CLI output
-        const cliOutput = typeof result.execution.output === 'string'
-          ? result.execution.output
-          : result.execution.output.stdout || '';
+        // Extract CLI output - prefer parsedOutput (extracted text from stream JSON)
+        let cliOutput = result.parsedOutput || '';
+        if (!cliOutput && result.execution?.output) {
+          cliOutput = typeof result.execution.output === 'string'
+            ? result.execution.output
+            : result.execution.output.stdout || '';
+        }
 
         if (!cliOutput || cliOutput.trim().length === 0) {
           return { error: 'CLI returned empty output', status: 500 };
@@ -810,15 +852,23 @@ export async function handleClaudeRoutes(ctx: RouteContext): Promise<boolean> {
   if (pathname === '/api/language/chinese-response' && req.method === 'GET') {
     try {
       const userClaudePath = join(homedir(), '.claude', 'CLAUDE.md');
+      const userCodexPath = join(homedir(), '.codex', 'AGENTS.md');
       const chineseRefPattern = /@.*chinese-response\.md/i;
 
-      let enabled = false;
+      let claudeEnabled = false;
+      let codexEnabled = false;
       let guidelinesPath = '';
 
       // Check if user CLAUDE.md exists and contains Chinese response reference
       if (existsSync(userClaudePath)) {
         const content = readFileSync(userClaudePath, 'utf8');
-        enabled = chineseRefPattern.test(content);
+        claudeEnabled = chineseRefPattern.test(content);
+      }
+
+      // Check if user AGENTS.md exists and contains Chinese response reference
+      if (existsSync(userCodexPath)) {
+        const content = readFileSync(userCodexPath, 'utf8');
+        codexEnabled = chineseRefPattern.test(content);
       }
 
       // Find guidelines file path - always use user-level path
@@ -830,10 +880,13 @@ export async function handleClaudeRoutes(ctx: RouteContext): Promise<boolean> {
 
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({
-        enabled,
+        enabled: claudeEnabled, // backward compatibility
+        claudeEnabled,
+        codexEnabled,
         guidelinesPath,
         guidelinesExists: !!guidelinesPath,
-        userClaudeMdExists: existsSync(userClaudePath)
+        userClaudeMdExists: existsSync(userClaudePath),
+        userCodexAgentsExists: existsSync(userCodexPath)
       }));
       return true;
     } catch (error) {
@@ -846,16 +899,13 @@ export async function handleClaudeRoutes(ctx: RouteContext): Promise<boolean> {
   // API: Toggle Chinese response setting
   if (pathname === '/api/language/chinese-response' && req.method === 'POST') {
     handlePostRequest(req, res, async (body: any) => {
-      const { enabled } = body;
+      const { enabled, target = 'claude' } = body; // target: 'claude' | 'codex'
 
       if (typeof enabled !== 'boolean') {
         return { error: 'Missing or invalid enabled parameter', status: 400 };
       }
 
       try {
-        const userClaudePath = join(homedir(), '.claude', 'CLAUDE.md');
-        const userClaudeDir = join(homedir(), '.claude');
-
         // Find guidelines file path - always use user-level path with ~ shorthand
         const userGuidelinesPath = join(homedir(), '.claude', 'workflows', 'chinese-response.md');
 
@@ -865,21 +915,27 @@ export async function handleClaudeRoutes(ctx: RouteContext): Promise<boolean> {
 
         const guidelinesRef = '~/.claude/workflows/chinese-response.md';
 
+        // Configure based on target
+        const isCodex = target === 'codex';
+        const targetDir = isCodex ? join(homedir(), '.codex') : join(homedir(), '.claude');
+        const targetFile = isCodex ? join(targetDir, 'AGENTS.md') : join(targetDir, 'CLAUDE.md');
+
         const chineseRefLine = `- **中文回复准则**: @${guidelinesRef}`;
         const chineseRefPattern = /^- \*\*中文回复准则\*\*:.*chinese-response\.md.*$/gm;
+        const chineseSectionPattern = /\n*## 中文回复\n+- \*\*中文回复准则\*\*:.*chinese-response\.md.*\n*/gm;
 
-        // Ensure user .claude directory exists
-        if (!existsSync(userClaudeDir)) {
-          const fs = require('fs');
-          fs.mkdirSync(userClaudeDir, { recursive: true });
+        // Ensure target directory exists
+        if (!existsSync(targetDir)) {
+          mkdirSync(targetDir, { recursive: true });
         }
 
         let content = '';
-        if (existsSync(userClaudePath)) {
-          content = readFileSync(userClaudePath, 'utf8');
+        if (existsSync(targetFile)) {
+          content = readFileSync(targetFile, 'utf8');
         } else {
-          // Create new CLAUDE.md with header
-          content = '# Claude Instructions\n\n';
+          // Create new file with minimal header
+          const headerText = isCodex ? '# Codex Code Guidelines\n\n' : '# Claude Instructions\n\n';
+          content = headerText;
         }
 
         if (enabled) {
@@ -888,30 +944,24 @@ export async function handleClaudeRoutes(ctx: RouteContext): Promise<boolean> {
             return { success: true, message: 'Already enabled' };
           }
 
-          // Add reference after the header line or at the beginning
-          const headerMatch = content.match(/^# Claude Instructions\n\n?/);
-          if (headerMatch) {
-            const insertPosition = headerMatch[0].length;
-            content = content.slice(0, insertPosition) + chineseRefLine + '\n' + content.slice(insertPosition);
-          } else {
-            // Add header and reference
-            content = '# Claude Instructions\n\n' + chineseRefLine + '\n' + content;
-          }
+          // Add new section at the end of file
+          const newSection = `\n## 中文回复\n\n${chineseRefLine}\n`;
+          content = content.trimEnd() + '\n' + newSection;
         } else {
-          // Remove reference
-          content = content.replace(chineseRefPattern, '').replace(/\n{3,}/g, '\n\n').trim();
+          // Remove the entire section
+          content = content.replace(chineseSectionPattern, '\n').replace(/\n{3,}/g, '\n\n').trim();
           if (content) content += '\n';
         }
 
-        writeFileSync(userClaudePath, content, 'utf8');
+        writeFileSync(targetFile, content, 'utf8');
 
         // Broadcast update
         broadcastToClients({
           type: 'LANGUAGE_SETTING_CHANGED',
-          data: { chineseResponse: enabled }
+          data: { chineseResponse: enabled, target }
         });
 
-        return { success: true, enabled };
+        return { success: true, enabled, target };
       } catch (error) {
         return { error: (error as Error).message, status: 500 };
       }

package/ccw/src/core/routes/cli-routes.ts

@@ -1,9 +1,7 @@
-// @ts-nocheck
 /**
  * CLI Routes Module
  * Handles all CLI-related API endpoints
  */
-import type { IncomingMessage, ServerResponse } from 'http';
 import {
   getCliToolsStatus,
   getCliToolsFullStatus,
@@ -25,6 +23,7 @@ import {
   getEnrichedConversation,
   getHistoryWithNativeInfo
 } from '../../tools/cli-executor.js';
+import { SmartContentFormatter } from '../../tools/cli-output-converter.js';
 import { generateSmartContext, formatSmartContext } from '../../tools/smart-context.js';
 import {
   loadCliConfig,
@@ -35,24 +34,42 @@ import {
 } from '../../tools/cli-config-manager.js';
 import {
   loadClaudeCliTools,
+  ensureClaudeCliTools,
   saveClaudeCliTools,
+  loadClaudeCliSettings,
+  saveClaudeCliSettings,
   updateClaudeToolEnabled,
   updateClaudeCacheSettings,
   getClaudeCliToolsInfo,
-  addClaudeCustomEndpoint,
-  removeClaudeCustomEndpoint,
+  addClaudeApiEndpoint,
+  removeClaudeApiEndpoint,
+  addClaudeCustomEndpoint,  // @deprecated - kept for backward compatibility
+  removeClaudeCustomEndpoint,  // @deprecated - kept for backward compatibility
   updateCodeIndexMcp,
   getCodeIndexMcp
 } from '../../tools/claude-cli-tools.js';
+import type { RouteContext } from './types.js';
+
+// ========== Active Executions State ==========
+// Stores running CLI executions for state recovery when view is opened/refreshed
+interface ActiveExecution {
+  id: string;
+  tool: string;
+  mode: string;
+  prompt: string;
+  startTime: number;
+  output: string;
+  status: 'running' | 'completed' | 'error';
+}
+
+const activeExecutions = new Map<string, ActiveExecution>();
 
-export interface RouteContext {
-  pathname: string;
-  url: URL;
-  req: IncomingMessage;
-  res: ServerResponse;
-  initialPath: string;
-  handlePostRequest: (req: IncomingMessage, res: ServerResponse, handler: (body: unknown) => Promise<any>) => void;
-  broadcastToClients: (data: unknown) => void;
+/**
+ * Get all active CLI executions
+ * Used by frontend to restore state when view is opened during execution
+ */
+export function getActiveExecutions(): ActiveExecution[] {
+  return Array.from(activeExecutions.values());
 }
 
 /**
@@ -62,6 +79,14 @@ export interface RouteContext {
 export async function handleCliRoutes(ctx: RouteContext): Promise<boolean> {
   const { pathname, url, req, res, initialPath, handlePostRequest, broadcastToClients } = ctx;
 
+  // API: Get Active CLI Executions (for state recovery)
+  if (pathname === '/api/cli/active' && req.method === 'GET') {
+    const executions = getActiveExecutions();
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ executions }));
+    return true;
+  }
+
   // API: CLI Tools Status
   if (pathname === '/api/cli/status') {
     const status = await getCliToolsStatus();
@@ -176,7 +201,7 @@ export async function handleCliRoutes(ctx: RouteContext): Promise<boolean> {
   }
 
   // API: Get/Update Tool Config
-  const configMatch = pathname.match(/^\/api\/cli\/config\/(gemini|qwen|codex)$/);
+  const configMatch = pathname.match(/^\/api\/cli\/config\/(gemini|qwen|codex|claude|opencode)$/);
   if (configMatch) {
     const tool = configMatch[1];
 
@@ -197,7 +222,7 @@ export async function handleCliRoutes(ctx: RouteContext): Promise<boolean> {
     if (req.method === 'PUT') {
       handlePostRequest(req, res, async (body: unknown) => {
         try {
-          const updates = body as { enabled?: boolean; primaryModel?: string; secondaryModel?: string };
+          const updates = body as { enabled?: boolean; primaryModel?: string; secondaryModel?: string; tags?: string[] };
           const updated = updateToolConfig(initialPath, tool, updates);
 
           // Broadcast config updated event
@@ -215,12 +240,21 @@ export async function handleCliRoutes(ctx: RouteContext): Promise<boolean> {
     }
   }
 
-  // API: Get all custom endpoints
+  // Helper: Get API endpoints from tools (type: 'api-endpoint')
+  const getApiEndpointsFromTools = (config: any) => {
+    return Object.entries(config.tools)
+      .filter(([_, t]: [string, any]) => t.type === 'api-endpoint')
+      .map(([name, t]: [string, any]) => ({ id: t.id || name, name, enabled: t.enabled }));
+  };
+
+  // API: Get all API endpoints (for --tool custom --model <id>)
   if (pathname === '/api/cli/endpoints' && req.method === 'GET') {
     try {
-      const config = loadClaudeCliTools(initialPath);
+      // Use ensureClaudeCliTools to auto-create config if missing
+      const config = ensureClaudeCliTools(initialPath);
+      const endpoints = getApiEndpointsFromTools(config);
       res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ endpoints: config.customEndpoints || [] }));
+      res.end(JSON.stringify({ endpoints }));
     } catch (err) {
       res.writeHead(500, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({ error: (err as Error).message }));
@@ -228,7 +262,7 @@ export async function handleCliRoutes(ctx: RouteContext): Promise<boolean> {
     return true;
   }
 
-  // API: Add/Update custom endpoint
+  // API: Add/Update API endpoint
   if (pathname === '/api/cli/endpoints' && req.method === 'POST') {
     handlePostRequest(req, res, async (body: unknown) => {
       try {
@@ -236,14 +270,14 @@ export async function handleCliRoutes(ctx: RouteContext): Promise<boolean> {
         if (!id || !name) {
           return { error: 'id and name are required', status: 400 };
         }
-        const config = addClaudeCustomEndpoint(initialPath, { id, name, enabled: enabled !== false });
+        const config = addClaudeApiEndpoint(initialPath, { id, name, enabled: enabled !== false });
 
         broadcastToClients({
           type: 'CLI_ENDPOINT_UPDATED',
           payload: { endpoint: { id, name, enabled }, timestamp: new Date().toISOString() }
         });
 
-        return { success: true, endpoints: config.customEndpoints };
+        return { success: true, endpoints: getApiEndpointsFromTools(config) };
       } catch (err) {
         return { error: (err as Error).message, status: 500 };
       }
@@ -251,24 +285,36 @@ export async function handleCliRoutes(ctx: RouteContext): Promise<boolean> {
     return true;
   }
 
-  // API: Update custom endpoint enabled status
+  // API: Update API endpoint enabled status
   if (pathname.match(/^\/api\/cli\/endpoints\/[^/]+$/) && req.method === 'PUT') {
     const endpointId = pathname.split('/').pop() || '';
     handlePostRequest(req, res, async (body: unknown) => {
       try {
-        const { enabled, name } = body as { enabled?: boolean; name?: string };
+        const { enabled, name: newName } = body as { enabled?: boolean; name?: string };
         const config = loadClaudeCliTools(initialPath);
-        const endpoint = config.customEndpoints.find(e => e.id === endpointId);
 
-        if (!endpoint) {
+        // Find the tool by id (api-endpoint type)
+        const toolEntry = Object.entries(config.tools).find(
+          ([_, t]: [string, any]) => t.type === 'api-endpoint' && t.id === endpointId
+        );
+
+        if (!toolEntry) {
           return { error: 'Endpoint not found', status: 404 };
         }
 
-        if (typeof enabled === 'boolean') endpoint.enabled = enabled;
-        if (name) endpoint.name = name;
+        const [toolName, tool] = toolEntry as [string, any];
+
+        if (typeof enabled === 'boolean') tool.enabled = enabled;
+        // If name changes, we need to rename the key
+        if (newName && newName !== toolName) {
+          delete config.tools[toolName];
+          config.tools[newName] = tool;
+        }
 
         saveClaudeCliTools(initialPath, config);
 
+        const endpoint = { id: tool.id || toolName, name: newName || toolName, enabled: tool.enabled };
+
         broadcastToClients({
           type: 'CLI_ENDPOINT_UPDATED',
           payload: { endpoint, timestamp: new Date().toISOString() }
@@ -282,11 +328,11 @@ export async function handleCliRoutes(ctx: RouteContext): Promise<boolean> {
     return true;
   }
 
-  // API: Delete custom endpoint
+  // API: Delete API endpoint
   if (pathname.match(/^\/api\/cli\/endpoints\/[^/]+$/) && req.method === 'DELETE') {
     const endpointId = pathname.split('/').pop() || '';
     try {
-      const config = removeClaudeCustomEndpoint(initialPath, endpointId);
+      const config = removeClaudeApiEndpoint(initialPath, endpointId);
 
       broadcastToClients({
         type: 'CLI_ENDPOINT_DELETED',
@@ -294,7 +340,7 @@ export async function handleCliRoutes(ctx: RouteContext): Promise<boolean> {
       });
 
       res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: true, endpoints: config.customEndpoints }));
+      res.end(JSON.stringify({ success: true, endpoints: getApiEndpointsFromTools(config) }));
     } catch (err) {
       res.writeHead(500, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({ error: (err as Error).message }));
@@ -504,6 +550,17 @@ export async function handleCliRoutes(ctx: RouteContext): Promise<boolean> {
 
       const executionId = `${Date.now()}-${tool}`;
 
+      // Store active execution for state recovery
+      activeExecutions.set(executionId, {
+        id: executionId,
+        tool,
+        mode: mode || 'analysis',
+        prompt: prompt.substring(0, 500), // Truncate for display
+        startTime: Date.now(),
+        output: '',
+        status: 'running'
+      });
+
       // Broadcast execution started
       broadcastToClients({
         type: 'CLI_EXECUTION_STARTED',
@@ -525,21 +582,33 @@ export async function handleCliRoutes(ctx: RouteContext): Promise<boolean> {
           model,
           cd: dir || initialPath,
           includeDirs,
-          timeout: timeout || 300000,
+          timeout: timeout || 0, // 0 = no internal timeout, controlled by external caller
           category: category || 'user',
           parentExecutionId,
           stream: true
-        }, (chunk) => {
+        }, (unit) => {
+          // CliOutputUnit handler: use SmartContentFormatter for intelligent formatting (never returns null)
+          const content = SmartContentFormatter.format(unit.content, unit.type);
+
+          // Append to active execution buffer
+          const activeExec = activeExecutions.get(executionId);
+          if (activeExec) {
+            activeExec.output += content || '';
+          }
+
           broadcastToClients({
             type: 'CLI_OUTPUT',
             payload: {
               executionId,
-              chunkType: chunk.type,
-              data: chunk.data
+              chunkType: unit.type,
+              data: content
             }
           });
         });
 
+        // Remove from active executions on completion
+        activeExecutions.delete(executionId);
+
         // Broadcast completion
         broadcastToClients({
           type: 'CLI_EXECUTION_COMPLETED',
@@ -557,6 +626,9 @@ export async function handleCliRoutes(ctx: RouteContext): Promise<boolean> {
         };
 
       } catch (error: unknown) {
+        // Remove from active executions on error
+        activeExecutions.delete(executionId);
+
         broadcastToClients({
           type: 'CLI_EXECUTION_ERROR',
           payload: {
@@ -659,11 +731,14 @@ export async function handleCliRoutes(ctx: RouteContext): Promise<boolean> {
   // API: Get CLI Tools Config from .claude/cli-tools.json (with fallback to global)
   if (pathname === '/api/cli/tools-config' && req.method === 'GET') {
     try {
-      const config = loadClaudeCliTools(initialPath);
+      // Use ensureClaudeCliTools to auto-create config if missing
+      const toolsConfig = ensureClaudeCliTools(initialPath);
+      const settingsConfig = loadClaudeCliSettings(initialPath);
       const info = getClaudeCliToolsInfo(initialPath);
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({
-        ...config,
+        tools: toolsConfig,
+        settings: settingsConfig,
         _configInfo: info
       }));
     } catch (err) {
@@ -677,32 +752,54 @@ export async function handleCliRoutes(ctx: RouteContext): Promise<boolean> {
   if (pathname === '/api/cli/tools-config' && req.method === 'PUT') {
     handlePostRequest(req, res, async (body: unknown) => {
       try {
-        const updates = body as Partial<any>;
-        const config = loadClaudeCliTools(initialPath);
+        const updates = body as { tools?: any; settings?: any };
+
+        // Update tools config if provided
+        if (updates.tools) {
+          const currentTools = loadClaudeCliTools(initialPath);
+          const updatedTools = {
+            ...currentTools,
+            tools: { ...currentTools.tools, ...(updates.tools.tools || {}) }
+          };
+          saveClaudeCliTools(initialPath, updatedTools);
+        }
 
-        // Merge updates
-        const updatedConfig = {
-          ...config,
-          ...updates,
-          tools: { ...config.tools, ...(updates.tools || {}) },
-          settings: {
-            ...config.settings,
-            ...(updates.settings || {}),
+        // Update settings config if provided
+        if (updates.settings) {
+          const currentSettings = loadClaudeCliSettings(initialPath);
+          const s = updates.settings;
+
+          // Deep merge: only update fields that are explicitly provided
+          const updatedSettings = {
+            ...currentSettings,
+            // Scalar fields: only update if explicitly provided
+            ...(s.defaultTool !== undefined && { defaultTool: s.defaultTool }),
+            ...(s.promptFormat !== undefined && { promptFormat: s.promptFormat }),
+            ...(s.nativeResume !== undefined && { nativeResume: s.nativeResume }),
+            ...(s.recursiveQuery !== undefined && { recursiveQuery: s.recursiveQuery }),
+            ...(s.codeIndexMcp !== undefined && { codeIndexMcp: s.codeIndexMcp }),
+            // Nested objects: deep merge
+            smartContext: {
+              ...currentSettings.smartContext,
+              ...(s.smartContext || {})
+            },
             cache: {
-              ...config.settings.cache,
-              ...(updates.settings?.cache || {})
+              ...currentSettings.cache,
+              ...(s.cache || {})
             }
-          }
-        };
+          };
+          saveClaudeCliSettings(initialPath, updatedSettings);
+        }
 
-        saveClaudeCliTools(initialPath, updatedConfig);
+        const toolsConfig = loadClaudeCliTools(initialPath);
+        const settingsConfig = loadClaudeCliSettings(initialPath);
 
         broadcastToClients({
           type: 'CLI_TOOLS_CONFIG_UPDATED',
-          payload: { config: updatedConfig, timestamp: new Date().toISOString() }
+          payload: { tools: toolsConfig, settings: settingsConfig, timestamp: new Date().toISOString() }
         });
 
-        return { success: true, config: updatedConfig };
+        return { success: true, tools: toolsConfig, settings: settingsConfig };
       } catch (err) {
         return { error: (err as Error).message, status: 500 };
       }
@@ -737,14 +834,14 @@ export async function handleCliRoutes(ctx: RouteContext): Promise<boolean> {
     handlePostRequest(req, res, async (body: unknown) => {
       try {
         const cacheSettings = body as { injectionMode?: string; defaultPrefix?: string; defaultSuffix?: string };
-        const config = updateClaudeCacheSettings(initialPath, cacheSettings as any);
+        const settings = updateClaudeCacheSettings(initialPath, cacheSettings as any);
 
         broadcastToClients({
           type: 'CLI_CACHE_SETTINGS_UPDATED',
-          payload: { cache: config.settings.cache, timestamp: new Date().toISOString() }
+          payload: { cache: settings.cache, timestamp: new Date().toISOString() }
         });
 
-        return { success: true, config };
+        return { success: true, settings };
       } catch (err) {
         return { error: (err as Error).message, status: 500 };
       }