coding-tool-x 3.5.4 → 3.5.6

package/src/server/services/session-launch-command.js

@@ -0,0 +1,81 @@
+const { isWindowsLikePlatform } = require('../../utils/home-dir');
+
+function escapeForDoubleQuotes(value) {
+  return String(value).replace(/"/g, '\\"');
+}
+
+function escapeForPowerShellSingleQuotes(value) {
+  return String(value).replace(/'/g, "''");
+}
+
+function buildDisplayCommand(executable, args = []) {
+  return [String(executable || ''), ...args.map(arg => String(arg))].filter(Boolean).join(' ').trim();
+}
+
+function buildWindowsCopyCommand(cwd, executable, args = []) {
+  const quotedCwd = `'${escapeForPowerShellSingleQuotes(cwd)}'`;
+  const quotedExecutable = `'${escapeForPowerShellSingleQuotes(executable)}'`;
+  const quotedArgs = args.map(arg => `'${escapeForPowerShellSingleQuotes(arg)}'`).join(' ');
+  const invokeCommand = quotedArgs
+    ? `& ${quotedExecutable} ${quotedArgs}`
+    : `& ${quotedExecutable}`;
+
+  return `powershell -NoProfile -ExecutionPolicy Bypass -Command "& { Set-Location -LiteralPath ${quotedCwd}; ${invokeCommand} }"`;
+}
+
+function buildPosixCopyCommand(cwd, command) {
+  const quotedCwd = `"${escapeForDoubleQuotes(cwd)}"`;
+  return `cd ${quotedCwd} && ${command}`;
+}
+
+function buildCopyCommand({
+  cwd,
+  command,
+  executable,
+  args = [],
+  runtimePlatform = process.platform,
+  runtimeEnv = process.env
+}) {
+  const resolvedCommand = command || buildDisplayCommand(executable, args);
+  if (!cwd) {
+    return resolvedCommand;
+  }
+
+  if (isWindowsLikePlatform(runtimePlatform, runtimeEnv)) {
+    return buildWindowsCopyCommand(cwd, executable, args);
+  }
+
+  return buildPosixCopyCommand(cwd, resolvedCommand);
+}
+
+function buildLaunchCommand({
+  cwd,
+  executable,
+  args = [],
+  runtimePlatform = process.platform,
+  runtimeEnv = process.env
+}) {
+  const command = buildDisplayCommand(executable, args);
+  return {
+    command,
+    copyCommand: buildCopyCommand({
+      cwd,
+      command,
+      executable,
+      args,
+      runtimePlatform,
+      runtimeEnv
+    })
+  };
+}
+
+module.exports = {
+  buildLaunchCommand,
+  _test: {
+    buildDisplayCommand,
+    buildCopyCommand,
+    buildWindowsCopyCommand,
+    buildPosixCopyCommand,
+    escapeForPowerShellSingleQuotes
+  }
+};

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/statistics-service.js

@@ -242,6 +242,13 @@ function recordRequest(requestData) {
       session,
       project
     };
+    // 如果有模型重定向信息，记录到日志中
+    if (requestData.originalModel) {
+      logEntry.originalModel = requestData.originalModel;
+    }
+    if (requestData.redirectedModel) {
+      logEntry.redirectedModel = requestData.redirectedModel;
+    }
     appendRequestLog(logEntry);
 
     // 2. 更新总体统计

package/src/server/websocket-server.js

@@ -504,11 +504,35 @@ 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
 };