claude-code-workflow 6.3.25 → 6.3.26

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

@@ -7,6 +7,29 @@ import { join } from 'path';
 import { homedir } from 'os';
 import type { RouteContext } from './types.js';
 
+/**
+ * Get the ccw-help index directory path (pure function)
+ * Priority: project path (.claude/skills/ccw-help/index) > user path (~/.claude/skills/ccw-help/index)
+ * @param projectPath - The project path to check first
+ */
+function getIndexDir(projectPath: string | null): string | null {
+  // Try project path first
+  if (projectPath) {
+    const projectIndexDir = join(projectPath, '.claude', 'skills', 'ccw-help', 'index');
+    if (existsSync(projectIndexDir)) {
+      return projectIndexDir;
+    }
+  }
+
+  // Fall back to user path
+  const userIndexDir = join(homedir(), '.claude', 'skills', 'ccw-help', 'index');
+  if (existsSync(userIndexDir)) {
+    return userIndexDir;
+  }
+
+  return null;
+}
+
 // ========== In-Memory Cache ==========
 interface CacheEntry {
   data: any;
@@ -61,14 +84,15 @@ let watchersInitialized = false;
 
 /**
  * Initialize file watchers for JSON indexes
+ * @param projectPath - The project path to resolve index directory
  */
-function initializeFileWatchers(): void {
+function initializeFileWatchers(projectPath: string | null): void {
   if (watchersInitialized) return;
 
-  const indexDir = join(homedir(), '.claude', 'skills', 'command-guide', 'index');
+  const indexDir = getIndexDir(projectPath);
 
-  if (!existsSync(indexDir)) {
-    console.warn(`Command guide index directory not found: ${indexDir}`);
+  if (!indexDir) {
+    console.warn(`ccw-help index directory not found in project or user paths`);
     return;
   }
 
@@ -152,15 +176,20 @@ function groupCommandsByCategory(commands: any[]): any {
  * @returns true if route was handled, false otherwise
  */
 export async function handleHelpRoutes(ctx: RouteContext): Promise<boolean> {
-  const { pathname, url, req, res } = ctx;
+  const { pathname, url, req, res, initialPath } = ctx;
 
   // Initialize file watchers on first request
-  initializeFileWatchers();
+  initializeFileWatchers(initialPath);
 
-  const indexDir = join(homedir(), '.claude', 'skills', 'command-guide', 'index');
+  const indexDir = getIndexDir(initialPath);
 
   // API: Get all commands with optional search
   if (pathname === '/api/help/commands') {
+    if (!indexDir) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'ccw-help index directory not found' }));
+      return true;
+    }
     const searchQuery = url.searchParams.get('q') || '';
     const filePath = join(indexDir, 'all-commands.json');
 
@@ -191,6 +220,11 @@ export async function handleHelpRoutes(ctx: RouteContext): Promise<boolean> {
 
   // API: Get workflow command relationships
   if (pathname === '/api/help/workflows') {
+    if (!indexDir) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'ccw-help index directory not found' }));
+      return true;
+    }
     const filePath = join(indexDir, 'command-relationships.json');
     const relationships = getCachedData('command-relationships', filePath);
 
@@ -207,6 +241,11 @@ export async function handleHelpRoutes(ctx: RouteContext): Promise<boolean> {
 
   // API: Get commands by category
   if (pathname === '/api/help/commands/by-category') {
+    if (!indexDir) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'ccw-help index directory not found' }));
+      return true;
+    }
     const filePath = join(indexDir, 'by-category.json');
     const byCategory = getCachedData('by-category', filePath);
 

package/ccw/src/core/routes/litellm-api-routes.ts

@@ -334,12 +334,43 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
         return true;
       }
 
-      // Test connection using litellm client
-      const client = getLiteLLMClient();
-      const available = await client.isAvailable();
+      // Get the API key to test (prefer first key from apiKeys array, fall back to default apiKey)
+      let apiKeyValue: string | null = null;
+      if (provider.apiKeys && provider.apiKeys.length > 0) {
+        apiKeyValue = provider.apiKeys[0].key;
+      } else if (provider.apiKey) {
+        apiKeyValue = provider.apiKey;
+      }
+
+      if (!apiKeyValue) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: false, error: 'No API key configured for this provider' }));
+        return true;
+      }
+
+      // Resolve environment variables in the API key
+      const { resolveEnvVar } = await import('../../config/litellm-api-config-manager.js');
+      const resolvedKey = resolveEnvVar(apiKeyValue);
+
+      if (!resolvedKey) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: false, error: 'API key is empty or environment variable not set' }));
+        return true;
+      }
+
+      // Determine API base URL
+      const apiBase = provider.apiBase || getDefaultApiBase(provider.type);
+
+      // Test the API key connection
+      const testResult = await testApiKeyConnection(provider.type, apiBase, resolvedKey);
 
       res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: available, provider: provider.type }));
+      res.end(JSON.stringify({
+        success: testResult.valid,
+        provider: provider.type,
+        latencyMs: testResult.latencyMs,
+        error: testResult.error,
+      }));
     } catch (err) {
       res.writeHead(500, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({ success: false, error: (err as Error).message }));

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

@@ -1256,5 +1256,89 @@ RULES: Be concise. Focus on practical understanding. Include function signatures
     return true;
   }
 
+  // API: Memory Queue - Add path to queue
+  if (pathname === '/api/memory/queue/add' && req.method === 'POST') {
+    handlePostRequest(req, res, async (body) => {
+      const { path: modulePath, tool = 'gemini', strategy = 'single-layer' } = body;
+
+      if (!modulePath) {
+        return { error: 'path is required', status: 400 };
+      }
+
+      try {
+        const { memoryQueueTool } = await import('../../tools/memory-update-queue.js');
+        const result = await memoryQueueTool.execute({
+          action: 'add',
+          path: modulePath,
+          tool,
+          strategy
+        }) as { queueSize?: number; willFlush?: boolean; flushed?: boolean };
+
+        // Broadcast queue update event
+        broadcastToClients({
+          type: 'MEMORY_QUEUE_UPDATED',
+          payload: {
+            action: 'add',
+            path: modulePath,
+            queueSize: result.queueSize || 0,
+            willFlush: result.willFlush || false,
+            flushed: result.flushed || false,
+            timestamp: new Date().toISOString()
+          }
+        });
+
+        return { success: true, ...result };
+      } catch (error: unknown) {
+        return { error: (error as Error).message, status: 500 };
+      }
+    });
+    return true;
+  }
+
+  // API: Memory Queue - Get queue status
+  if (pathname === '/api/memory/queue/status' && req.method === 'GET') {
+    try {
+      const { memoryQueueTool } = await import('../../tools/memory-update-queue.js');
+      const result = await memoryQueueTool.execute({ action: 'status' }) as Record<string, unknown>;
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ success: true, ...result }));
+    } catch (error: unknown) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: (error as Error).message }));
+    }
+    return true;
+  }
+
+  // API: Memory Queue - Flush queue immediately
+  if (pathname === '/api/memory/queue/flush' && req.method === 'POST') {
+    handlePostRequest(req, res, async () => {
+      try {
+        const { memoryQueueTool } = await import('../../tools/memory-update-queue.js');
+        const result = await memoryQueueTool.execute({ action: 'flush' }) as {
+          processed?: number;
+          success?: boolean;
+          errors?: unknown[];
+        };
+
+        // Broadcast queue flushed event
+        broadcastToClients({
+          type: 'MEMORY_QUEUE_FLUSHED',
+          payload: {
+            processed: result.processed || 0,
+            success: result.success || false,
+            errors: result.errors?.length || 0,
+            timestamp: new Date().toISOString()
+          }
+        });
+
+        return { success: true, ...result };
+      } catch (error: unknown) {
+        return { error: (error as Error).message, status: 500 };
+      }
+    });
+    return true;
+  }
+
   return false;
 }

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

@@ -9,6 +9,15 @@ import { getCliToolsStatus } from '../../tools/cli-executor.js';
 import { checkVenvStatus, checkSemanticStatus } from '../../tools/codex-lens.js';
 import type { RouteContext } from './types.js';
 
+// Performance logging helper
+const PERF_LOG_ENABLED = process.env.CCW_PERF_LOG === '1' || true; // Enable by default for debugging
+function perfLog(label: string, startTime: number, extra?: Record<string, unknown>): void {
+  if (!PERF_LOG_ENABLED) return;
+  const duration = Date.now() - startTime;
+  const extraStr = extra ? ` | ${JSON.stringify(extra)}` : '';
+  console.log(`[PERF][Status] ${label}: ${duration}ms${extraStr}`);
+}
+
 /**
  * Check CCW installation status
  * Verifies that required workflow files are installed in user's home directory
@@ -62,16 +71,39 @@ export async function handleStatusRoutes(ctx: RouteContext): Promise<boolean> {
 
   // API: Aggregated Status (all statuses in one call)
   if (pathname === '/api/status/all') {
+    const totalStart = Date.now();
+    console.log('[PERF][Status] === /api/status/all START ===');
+
     try {
       // Check CCW installation status (sync, fast)
+      const ccwStart = Date.now();
       const ccwInstallStatus = checkCcwInstallStatus();
+      perfLog('checkCcwInstallStatus', ccwStart);
+
+      // Execute all status checks in parallel with individual timing
+      const cliStart = Date.now();
+      const codexStart = Date.now();
+      const semanticStart = Date.now();
 
-      // Execute all status checks in parallel
       const [cliStatus, codexLensStatus, semanticStatus] = await Promise.all([
-        getCliToolsStatus(),
-        checkVenvStatus(),
+        getCliToolsStatus().then(result => {
+          perfLog('getCliToolsStatus', cliStart, { toolCount: Object.keys(result).length });
+          return result;
+        }),
+        checkVenvStatus().then(result => {
+          perfLog('checkVenvStatus', codexStart, { ready: result.ready });
+          return result;
+        }),
         // Always check semantic status (will return available: false if CodexLens not ready)
-        checkSemanticStatus().catch(() => ({ available: false, backend: null }))
+        checkSemanticStatus()
+          .then(result => {
+            perfLog('checkSemanticStatus', semanticStart, { available: result.available });
+            return result;
+          })
+          .catch(() => {
+            perfLog('checkSemanticStatus (error)', semanticStart);
+            return { available: false, backend: null };
+          })
       ]);
 
       const response = {
@@ -82,10 +114,13 @@ export async function handleStatusRoutes(ctx: RouteContext): Promise<boolean> {
         timestamp: new Date().toISOString()
       };
 
+      perfLog('=== /api/status/all TOTAL ===', totalStart);
+
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify(response));
       return true;
     } catch (error) {
+      perfLog('=== /api/status/all ERROR ===', totalStart);
       console.error('[Status Routes] Error fetching aggregated status:', error);
       res.writeHead(500, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({ error: (error as Error).message }));

package/ccw/src/core/server.ts

@@ -42,6 +42,10 @@ import { randomBytes } from 'crypto';
 // Import health check service
 import { getHealthCheckService } from './services/health-check-service.js';
 
+// Import status check functions for warmup
+import { checkSemanticStatus, checkVenvStatus } from '../tools/codex-lens.js';
+import { getCliToolsStatus } from '../tools/cli-executor.js';
+
 import type { ServerConfig } from '../types/config.js';
 import type { PostRequestHandler } from './routes/types.js';
 
@@ -290,6 +294,56 @@ function setCsrfCookie(res: http.ServerResponse, token: string, maxAgeSeconds: n
   appendSetCookie(res, attributes.join('; '));
 }
 
+/**
+ * Warmup function to pre-populate caches on server startup
+ * This runs asynchronously and non-blocking after the server starts
+ */
+async function warmupCaches(initialPath: string): Promise<void> {
+  console.log('[WARMUP] Starting cache warmup...');
+  const startTime = Date.now();
+
+  // Run all warmup tasks in parallel for faster startup
+  const warmupTasks = [
+    // Warmup semantic status cache (Python process startup - can be slow first time)
+    (async () => {
+      const taskStart = Date.now();
+      try {
+        const semanticStatus = await checkSemanticStatus();
+        console.log(`[WARMUP] Semantic status: ${semanticStatus.available ? 'available' : 'not available'} (${Date.now() - taskStart}ms)`);
+      } catch (err) {
+        console.warn(`[WARMUP] Semantic status check failed: ${(err as Error).message}`);
+      }
+    })(),
+
+    // Warmup venv status cache
+    (async () => {
+      const taskStart = Date.now();
+      try {
+        const venvStatus = await checkVenvStatus();
+        console.log(`[WARMUP] Venv status: ${venvStatus.ready ? 'ready' : 'not ready'} (${Date.now() - taskStart}ms)`);
+      } catch (err) {
+        console.warn(`[WARMUP] Venv status check failed: ${(err as Error).message}`);
+      }
+    })(),
+
+    // Warmup CLI tools status cache
+    (async () => {
+      const taskStart = Date.now();
+      try {
+        const cliStatus = await getCliToolsStatus();
+        const availableCount = Object.values(cliStatus).filter(s => s.available).length;
+        const totalCount = Object.keys(cliStatus).length;
+        console.log(`[WARMUP] CLI tools status: ${availableCount}/${totalCount} available (${Date.now() - taskStart}ms)`);
+      } catch (err) {
+        console.warn(`[WARMUP] CLI tools status check failed: ${(err as Error).message}`);
+      }
+    })()
+  ];
+
+  await Promise.allSettled(warmupTasks);
+  console.log(`[WARMUP] Cache warmup complete (${Date.now() - startTime}ms total)`);
+}
+
 /**
  * Generate dashboard HTML with embedded CSS and JS
  */
@@ -650,6 +704,14 @@ export async function startServer(options: ServerOptions = {}): Promise<http.Ser
         console.warn('[Server] Failed to start health check service:', err);
       }
 
+      // Start cache warmup asynchronously (non-blocking)
+      // Uses setImmediate to not delay server startup response
+      setImmediate(() => {
+        warmupCaches(initialPath).catch((err) => {
+          console.warn('[WARMUP] Cache warmup failed:', err);
+        });
+      });
+
       resolve(server);
     });
     server.on('error', reject);

package/ccw/src/core/services/api-key-tester.ts

@@ -72,6 +72,10 @@ export async function testApiKeyConnection(
     return { valid: false, error: urlValidation.error };
   }
 
+  // Normalize apiBase: remove trailing slashes to prevent URL construction issues
+  // e.g., "https://api.openai.com/v1/" -> "https://api.openai.com/v1"
+  const normalizedApiBase = apiBase.replace(/\/+$/, '');
+
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), timeout);
   const startTime = Date.now();
@@ -80,7 +84,7 @@ export async function testApiKeyConnection(
     if (providerType === 'anthropic') {
       // Anthropic format: Use /v1/models endpoint (no cost, no model dependency)
       // This validates the API key without making a billable request
-      const response = await fetch(`${apiBase}/models`, {
+      const response = await fetch(`${normalizedApiBase}/models`, {
         method: 'GET',
         headers: {
           'x-api-key': apiKey,
@@ -114,8 +118,10 @@ export async function testApiKeyConnection(
 
       return { valid: false, error: errorMessage };
     } else {
-      // OpenAI-compatible format: GET /v1/models
-      const modelsUrl = apiBase.endsWith('/v1') ? `${apiBase}/models` : `${apiBase}/v1/models`;
+      // OpenAI-compatible format: GET /v{N}/models
+      // Detect if URL already ends with a version pattern like /v1, /v2, /v4, etc.
+      const hasVersionSuffix = /\/v\d+$/.test(normalizedApiBase);
+      const modelsUrl = hasVersionSuffix ? `${normalizedApiBase}/models` : `${normalizedApiBase}/v1/models`;
       const response = await fetch(modelsUrl, {
         method: 'GET',
         headers: {

package/ccw/src/templates/dashboard-css/21-cli-toolmgmt.css

@@ -304,6 +304,51 @@
   margin-top: 0;
 }
 
+/* Environment File Input Group */
+.env-file-input-group {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+
+.env-file-input-row {
+  display: flex;
+  gap: 0.5rem;
+  align-items: center;
+}
+
+.env-file-input-row .tool-config-input {
+  flex: 1;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 0.8125rem;
+  margin-top: 0;
+}
+
+.env-file-input-row .btn-sm {
+  flex-shrink: 0;
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+  padding: 0.5rem 0.75rem;
+  font-size: 0.8125rem;
+  white-space: nowrap;
+}
+
+.env-file-hint {
+  display: flex;
+  align-items: center;
+  gap: 0.375rem;
+  font-size: 0.75rem;
+  color: hsl(var(--muted-foreground));
+  margin: 0;
+  padding: 0;
+}
+
+.env-file-hint i {
+  flex-shrink: 0;
+  opacity: 0.7;
+}
+
 .btn-ghost.text-destructive:hover {
   background: hsl(var(--destructive) / 0.1);
 }

package/ccw/src/templates/dashboard-js/components/cli-status.js

@@ -33,11 +33,14 @@ function initCliStatus() {
  * Load all statuses using aggregated endpoint (single API call)
  */
 async function loadAllStatuses() {
+  const totalStart = performance.now();
+  console.log('[PERF][Frontend] loadAllStatuses START');
+
   // 1. 尝试从缓存获取（预加载的数据）
   if (window.cacheManager) {
     const cached = window.cacheManager.get('all-status');
     if (cached) {
-      console.log('[CLI Status] Loaded all statuses from cache');
+      console.log(`[PERF][Frontend] Cache hit: ${(performance.now() - totalStart).toFixed(1)}ms`);
       // 应用缓存数据
       cliToolStatus = cached.cli || {};
       codexLensStatus = cached.codexLens || { ready: false };
@@ -45,25 +48,32 @@ async function loadAllStatuses() {
       ccwInstallStatus = cached.ccwInstall || { installed: true, workflowsInstalled: true, missingFiles: [], installPath: '' };
 
       // Load CLI tools config, API endpoints, and CLI Settings（这些有自己的缓存）
+      const configStart = performance.now();
       await Promise.all([
         loadCliToolsConfig(),
         loadApiEndpoints(),
         loadCliSettingsEndpoints()
       ]);
+      console.log(`[PERF][Frontend] Config/Endpoints load: ${(performance.now() - configStart).toFixed(1)}ms`);
 
       // Update badges
       updateCliBadge();
       updateCodexLensBadge();
       updateCcwInstallBadge();
+
+      console.log(`[PERF][Frontend] loadAllStatuses TOTAL (cached): ${(performance.now() - totalStart).toFixed(1)}ms`);
       return cached;
     }
   }
 
   // 2. 缓存未命中，从服务器获取
   try {
+    const fetchStart = performance.now();
+    console.log('[PERF][Frontend] Fetching /api/status/all...');
     const response = await fetch('/api/status/all');
     if (!response.ok) throw new Error('Failed to load status');
     const data = await response.json();
+    console.log(`[PERF][Frontend] /api/status/all fetch: ${(performance.now() - fetchStart).toFixed(1)}ms`);
 
     // 存入缓存
     if (window.cacheManager) {
@@ -77,10 +87,11 @@ async function loadAllStatuses() {
     ccwInstallStatus = data.ccwInstall || { installed: true, workflowsInstalled: true, missingFiles: [], installPath: '' };
 
     // Load CLI tools config, API endpoints, and CLI Settings
-    await Promise.all([
-      loadCliToolsConfig(),
-      loadApiEndpoints(),
-      loadCliSettingsEndpoints()
+    const configStart = performance.now();
+    const [configResult, endpointsResult, settingsResult] = await Promise.all([
+      loadCliToolsConfig().then(r => { console.log(`[PERF][Frontend] loadCliToolsConfig: ${(performance.now() - configStart).toFixed(1)}ms`); return r; }),
+      loadApiEndpoints().then(r => { console.log(`[PERF][Frontend] loadApiEndpoints: ${(performance.now() - configStart).toFixed(1)}ms`); return r; }),
+      loadCliSettingsEndpoints().then(r => { console.log(`[PERF][Frontend] loadCliSettingsEndpoints: ${(performance.now() - configStart).toFixed(1)}ms`); return r; })
     ]);
 
     // Update badges
@@ -88,9 +99,11 @@ async function loadAllStatuses() {
     updateCodexLensBadge();
     updateCcwInstallBadge();
 
+    console.log(`[PERF][Frontend] loadAllStatuses TOTAL: ${(performance.now() - totalStart).toFixed(1)}ms`);
     return data;
   } catch (err) {
     console.error('Failed to load aggregated status:', err);
+    console.log(`[PERF][Frontend] loadAllStatuses ERROR after: ${(performance.now() - totalStart).toFixed(1)}ms`);
     // Fallback to individual calls if aggregated endpoint fails
     return await loadAllStatusesFallback();
   }
@@ -1034,6 +1047,15 @@ async function startCodexLensInstall() {
       progressBar.style.width = '100%';
       statusText.textContent = 'Installation complete!';
 
+      // 清理缓存以确保刷新后获取最新状态
+      if (window.cacheManager) {
+        window.cacheManager.invalidate('all-status');
+        window.cacheManager.invalidate('dashboard-init');
+      }
+      if (typeof window.invalidateCodexLensCache === 'function') {
+        window.invalidateCodexLensCache();
+      }
+
       setTimeout(() => {
         closeCodexLensInstallWizard();
         showRefreshToast('CodexLens installed successfully!', 'success');
@@ -1184,6 +1206,15 @@ async function startCodexLensUninstall() {
       progressBar.style.width = '100%';
       statusText.textContent = 'Uninstallation complete!';
 
+      // 清理缓存以确保刷新后获取最新状态
+      if (window.cacheManager) {
+        window.cacheManager.invalidate('all-status');
+        window.cacheManager.invalidate('dashboard-init');
+      }
+      if (typeof window.invalidateCodexLensCache === 'function') {
+        window.invalidateCodexLensCache();
+      }
+
       setTimeout(() => {
         closeCodexLensUninstallWizard();
         showRefreshToast('CodexLens uninstalled successfully!', 'success');