coding-tool-x 3.5.5 → 3.5.7

package/src/server/services/sessions.js

@@ -16,6 +16,9 @@ const { PATHS, NATIVE_PATHS } = require('../../config/paths');
 const CLAUDE_PROJECTS_DIR = NATIVE_PATHS.claude.projects;
 const CODEX_PROJECTS_DIR = path.join(path.dirname(NATIVE_PATHS.codex.config), 'projects');
 const GEMINI_PROJECTS_DIR = path.join(path.dirname(NATIVE_PATHS.gemini.env), 'projects');
+const PROJECT_PATH_CACHE_TTL_MS = 5 * 60 * 1000;
+const MAX_PROJECT_PATH_CACHE_ENTRIES = 500;
+let projectPathResolutionCache = new Map();
 
 // Base directory for cc-tool data
 function getCcToolDir() {
@@ -100,15 +103,82 @@ async function getProjects(config) {
     .map(entry => entry.name);
 }
 
+function getProjectPathCacheKey(encodedName) {
+  return `${process.platform}:${encodedName}`;
+}
+
+function cloneProjectPathResolution(value) {
+  return {
+    fullPath: value?.fullPath || '',
+    projectName: value?.projectName || ''
+  };
+}
+
+function getCachedProjectPathResolution(encodedName) {
+  const cacheKey = getProjectPathCacheKey(encodedName);
+  const cached = projectPathResolutionCache.get(cacheKey);
+  if (!cached) {
+    return null;
+  }
+
+  if (cached.expiresAt <= Date.now()) {
+    projectPathResolutionCache.delete(cacheKey);
+    return null;
+  }
+
+  return cloneProjectPathResolution(cached.value);
+}
+
+function setCachedProjectPathResolution(encodedName, value) {
+  const cacheKey = getProjectPathCacheKey(encodedName);
+  projectPathResolutionCache.delete(cacheKey);
+  projectPathResolutionCache.set(cacheKey, {
+    expiresAt: Date.now() + PROJECT_PATH_CACHE_TTL_MS,
+    value: cloneProjectPathResolution(value)
+  });
+
+  while (projectPathResolutionCache.size > MAX_PROJECT_PATH_CACHE_ENTRIES) {
+    const oldestKey = projectPathResolutionCache.keys().next().value;
+    if (!oldestKey) {
+      break;
+    }
+    projectPathResolutionCache.delete(oldestKey);
+  }
+}
+
+function clearProjectPathResolutionCache(encodedName) {
+  if (!encodedName) {
+    projectPathResolutionCache.clear();
+    return;
+  }
+
+  projectPathResolutionCache.delete(getProjectPathCacheKey(encodedName));
+}
+
 // Parse real project path from encoded name
 // macOS/Linux: "-Users-lilithgames-work-project" -> "/Users/lilithgames/work/project"
 // Windows: "C--Users-admin-Desktop-project" -> "C:\Users\admin\Desktop\project"
 function parseRealProjectPath(encodedName) {
+  const normalizedEncodedName = String(encodedName || '').trim();
+  const cached = getCachedProjectPathResolution(normalizedEncodedName);
+  if (cached) {
+    return cached;
+  }
+
   const isWindows = process.platform === 'win32';
-  const fallbackFromSessions = tryResolvePathFromSessions(encodedName);
+  const fallbackFromSessions = tryResolvePathFromSessions(normalizedEncodedName);
+
+  if (fallbackFromSessions?.fullPath) {
+    const resolved = {
+      fullPath: fallbackFromSessions.fullPath,
+      projectName: fallbackFromSessions.projectName || path.basename(fallbackFromSessions.fullPath) || normalizedEncodedName
+    };
+    setCachedProjectPathResolution(normalizedEncodedName, resolved);
+    return resolved;
+  }
 
   // Detect Windows drive letter (e.g., "C--Users-admin")
-  const windowsDriveMatch = encodedName.match(/^([A-Z])--(.+)$/);
+  const windowsDriveMatch = normalizedEncodedName.match(/^([A-Z])--(.+)$/);
 
   if (isWindows && windowsDriveMatch) {
     // Windows path with drive letter
@@ -167,13 +237,15 @@ function parseRealProjectPath(encodedName) {
       currentPath = driveLetter + ':\\' + realSegments.join('\\');
     }
 
-    return {
-      fullPath: validateProjectPath(currentPath) || fallbackFromSessions?.fullPath || (driveLetter + ':\\' + restPath.replace(/-/g, '\\')),
-      projectName: fallbackFromSessions?.projectName || realSegments[realSegments.length - 1] || encodedName
+    const resolved = {
+      fullPath: validateProjectPath(currentPath) || (driveLetter + ':\\' + restPath.replace(/-/g, '\\')),
+      projectName: realSegments[realSegments.length - 1] || normalizedEncodedName
     };
+    setCachedProjectPathResolution(normalizedEncodedName, resolved);
+    return resolved;
   } else {
     // Unix-like path (macOS/Linux) or fallback
-    const pathStr = encodedName.replace(/^-/, '/').replace(/-/g, '/');
+    const pathStr = normalizedEncodedName.replace(/^-/, '/').replace(/-/g, '/');
     const segments = pathStr.split('/').filter(s => s);
 
     // Build path from left to right, checking existence
@@ -225,10 +297,12 @@ function parseRealProjectPath(encodedName) {
       currentPath = '/' + realSegments.join('/');
     }
 
-    return {
-      fullPath: validateProjectPath(currentPath) || fallbackFromSessions?.fullPath || pathStr,
-      projectName: fallbackFromSessions?.projectName || realSegments[realSegments.length - 1] || encodedName
+    const resolved = {
+      fullPath: validateProjectPath(currentPath) || pathStr,
+      projectName: realSegments[realSegments.length - 1] || normalizedEncodedName
     };
+    setCachedProjectPathResolution(normalizedEncodedName, resolved);
+    return resolved;
   }
 }
 
@@ -347,27 +421,20 @@ async function buildProjectsWithStats(config) {
         const files = await fs.promises.readdir(projectPath);
         const jsonlFiles = files.filter(f => f.endsWith('.jsonl') && !f.startsWith('agent-'));
 
-        // Filter: only count sessions that have actual messages (in parallel)
         const sessionChecks = await Promise.all(
-          jsonlFiles.map(async (f) => {
-            const filePath = path.join(projectPath, f);
-            const hasMessages = await hasActualMessages(filePath);
-            return hasMessages ? f : null;
+          jsonlFiles.map(async (fileName) => {
+            const filePath = path.join(projectPath, fileName);
+            const stats = await fs.promises.stat(filePath);
+            const hasMessages = await hasActualMessages(filePath, stats);
+            return hasMessages ? stats.mtime.getTime() : null;
           })
         );
 
-        const sessionFilesWithMessages = sessionChecks.filter(f => f !== null);
-        sessionCount = sessionFilesWithMessages.length;
+        const activeSessionTimes = sessionChecks.filter((mtimeMs) => Number.isFinite(mtimeMs));
+        sessionCount = activeSessionTimes.length;
 
-        // Find most recent session (only from sessions with messages)
-        if (sessionFilesWithMessages.length > 0) {
-          const statPromises = sessionFilesWithMessages.map(async (f) => {
-            const filePath = path.join(projectPath, f);
-            const stat = await fs.promises.stat(filePath);
-            return stat.mtime.getTime();
-          });
-          const stats = await Promise.all(statPromises);
-          lastUsed = Math.max(...stats);
+        if (activeSessionTimes.length > 0) {
+          lastUsed = Math.max(...activeSessionTimes);
         }
       } catch (err) {
         // Ignore errors
@@ -415,9 +482,9 @@ function getProjectAndSessionCounts(config) {
 }
 
 // Check if a session file has actual messages (async with enhanced caching)
-async function hasActualMessages(filePath) {
+async function hasActualMessages(filePath, statsOverride = null) {
   try {
-    const stats = await fs.promises.stat(filePath);
+    const stats = statsOverride || await fs.promises.stat(filePath);
 
     // Check enhanced cache first
     const cacheKey = `${CacheKeys.HAS_MESSAGES}${filePath}:${stats.mtime.getTime()}`;
@@ -658,14 +725,13 @@ function saveSessionOrder(projectName, order) {
 // Delete a project (remove the entire project directory)
 function deleteProject(config, projectName) {
   const projectDir = path.join(config.projectsDir, projectName);
+  const existed = fs.existsSync(projectDir);
 
-  if (!fs.existsSync(projectDir)) {
-    throw new Error('Project not found');
+  if (existed) {
+    // Recursively delete the directory
+    fs.rmSync(projectDir, { recursive: true, force: true });
   }
 
-  // Recursively delete the directory
-  fs.rmSync(projectDir, { recursive: true, force: true });
-
   // Remove from order file if exists
   const order = getProjectOrder(config);
   const newOrder = order.filter(name => name !== projectName);
@@ -674,7 +740,11 @@ function deleteProject(config, projectName) {
   }
 
   invalidateProjectsCache(config);
-  return { success: true };
+  clearProjectPathResolutionCache(projectName);
+  return {
+    success: true,
+    alreadyDeleted: !existed
+  };
 }
 
 // Search sessions for keyword

package/src/server/services/web-ui-runtime.js

@@ -0,0 +1,54 @@
+function normalizeWebUiProtocol(value) {
+  return String(value || '').trim().toLowerCase() === 'https' ? 'https' : 'http';
+}
+
+function hasHttpsFlag(argv = process.argv) {
+  return Array.isArray(argv) && argv.includes('--https');
+}
+
+function getWebUiProtocol(options = {}) {
+  if (typeof options.https === 'boolean') {
+    return options.https ? 'https' : 'http';
+  }
+
+  if (typeof options.protocol === 'string' && options.protocol.trim()) {
+    return normalizeWebUiProtocol(options.protocol);
+  }
+
+  const env = options.env || process.env;
+  if (env && typeof env.CC_TOOL_WEB_UI_PROTOCOL === 'string' && env.CC_TOOL_WEB_UI_PROTOCOL.trim()) {
+    return normalizeWebUiProtocol(env.CC_TOOL_WEB_UI_PROTOCOL);
+  }
+
+  return hasHttpsFlag(options.argv || process.argv) ? 'https' : 'http';
+}
+
+function isHttpsEnabled(options = {}) {
+  return getWebUiProtocol(options) === 'https';
+}
+
+function getDefaultLoopbackHost(protocol = 'http') {
+  return normalizeWebUiProtocol(protocol) === 'https' ? '127.0.0.1' : 'localhost';
+}
+
+function getWebUiBaseUrl(port, options = {}) {
+  const protocol = getWebUiProtocol(options);
+  const hostname = String(options.hostname || '').trim() || getDefaultLoopbackHost(protocol);
+  return `${protocol}://${hostname}:${port}`;
+}
+
+function getWebSocketBaseUrl(port, options = {}) {
+  const protocol = getWebUiProtocol(options) === 'https' ? 'wss' : 'ws';
+  const hostname = String(options.hostname || '').trim() || getDefaultLoopbackHost(protocol === 'wss' ? 'https' : 'http');
+  return `${protocol}://${hostname}:${port}`;
+}
+
+module.exports = {
+  normalizeWebUiProtocol,
+  hasHttpsFlag,
+  getWebUiProtocol,
+  isHttpsEnabled,
+  getDefaultLoopbackHost,
+  getWebUiBaseUrl,
+  getWebSocketBaseUrl
+};

package/src/server/websocket-server.js

@@ -7,7 +7,9 @@ const { PATHS } = require('../config/paths');
 const {
   normalizeAddress,
   isLoopbackAddress,
-  isLoopbackRequest
+  isLoopbackRequest,
+  getRequestProtocol,
+  getRequestHost
 } = require('./services/network-access');
 
 const MAX_PERSISTED_LOGS = 500;
@@ -111,8 +113,8 @@ function isAllowedWebSocketOrigin(req) {
     return false;
   }
 
-  const requestHost = parseHostHeader(req.headers.host);
-  const requestProtocol = req.socket && req.socket.encrypted ? 'https:' : 'http:';
+  const requestHost = parseHostHeader(getRequestHost(req));
+  const requestProtocol = getRequestProtocol(req);
   const requestHostname = normalizeAddress(requestHost.hostname).toLowerCase();
   const requestPort = requestHost.port || defaultPortForProtocol(requestProtocol);
 
@@ -504,11 +506,40 @@ function broadcastSchedulerState(source, schedulerState) {
   }
 }
 
+function broadcastBrowserNotification(event = {}) {
+  const notification = {
+    type: 'browser-notification',
+    title: String(event.title || '').trim() || 'Coding Tool',
+    source: String(event.source || '').trim() || 'claude',
+    sourceLabel: String(event.sourceLabel || '').trim() || 'Claude Code',
+    mode: String(event.mode || '').trim() || 'notification',
+    eventType: String(event.eventType || '').trim(),
+    message: String(event.message || '').trim() || '任务已完成 | 等待交互',
+    timestamp: typeof event.timestamp === 'number' ? event.timestamp : Date.now()
+  };
+
+  if (wss && wsClients.size > 0) {
+    const message = JSON.stringify(notification);
+
+    wsClients.forEach(client => {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(message);
+      }
+    });
+  }
+}
+
 module.exports = {
   startWebSocketServer,
   stopWebSocketServer,
   broadcastLog,
   clearAllLogs,
   broadcastProxyState,
-  broadcastSchedulerState
+  broadcastSchedulerState,
+  broadcastBrowserNotification,
+  _test: {
+    parseHostHeader,
+    defaultPortForProtocol,
+    isAllowedWebSocketOrigin
+  }
 };