coding-tool-x 3.7.4 → 3.7.5

package/src/server/services/dashboard-snapshot-worker.js

@@ -0,0 +1,216 @@
+'use strict';
+
+const { fork } = require('child_process');
+
+const DASHBOARD_SNAPSHOT_WORKER_TIMEOUT_MS = 120 * 1000;
+
+function sortClaudeProjects(projects, order = []) {
+  if (!Array.isArray(order) || order.length === 0) {
+    return projects;
+  }
+  const orderMap = new Map(order.map((name, idx) => [name, idx]));
+  return [...projects].sort((a, b) => {
+    const aIdx = orderMap.has(a.name) ? orderMap.get(a.name) : 999999;
+    const bIdx = orderMap.has(b.name) ? orderMap.get(b.name) : 999999;
+    if (aIdx === bIdx) {
+      return (b.lastUsed || 0) - (a.lastUsed || 0);
+    }
+    return aIdx - bIdx;
+  });
+}
+
+async function buildProjectsPayload(source, config = {}, options = {}) {
+  switch (source) {
+    case 'claude': {
+      const { getProjectsWithStats, getProjectOrder } = require('./sessions');
+      const projects = await getProjectsWithStats(config, { force: options.force === true });
+      const sortedProjects = sortClaudeProjects(projects, getProjectOrder(config));
+      return {
+        projects: sortedProjects,
+        currentProject: config.currentProject || (sortedProjects[0] ? sortedProjects[0].name : null)
+      };
+    }
+    case 'codex': {
+      const { getProjects } = require('./codex-sessions');
+      const projects = getProjects({ force: options.force === true });
+      return { projects, currentProject: projects[0] ? projects[0].name : null };
+    }
+    case 'gemini': {
+      const { getProjects } = require('./gemini-sessions');
+      const projects = getProjects({ force: options.force === true });
+      return { projects, currentProject: projects[0] ? projects[0].name : null };
+    }
+    case 'opencode': {
+      const { getProjects } = require('./opencode-sessions');
+      const projects = getProjects({ force: options.force === true });
+      return { projects, currentProject: projects[0] ? projects[0].name : null };
+    }
+    case 'omp': {
+      const { getProjects } = require('./omp-sessions');
+      const projects = getProjects({ force: options.force === true });
+      return { projects, currentProject: projects[0] ? projects[0].name : null };
+    }
+    default:
+      throw new Error(`Unsupported project snapshot source: ${source}`);
+  }
+}
+
+function buildCountsPayload(source, config = {}, options = {}) {
+  switch (source) {
+    case 'claude':
+      return require('./sessions').getProjectAndSessionCounts(config, { force: options.force === true });
+    case 'codex':
+      return require('./codex-sessions').getProjectAndSessionCounts({ force: options.force === true });
+    case 'gemini':
+      return require('./gemini-sessions').getProjectAndSessionCounts({ force: options.force === true });
+    case 'opencode':
+      return require('./opencode-sessions').getProjectAndSessionCounts({ force: options.force === true });
+    case 'omp':
+      return require('./omp-sessions').getProjectAndSessionCounts({ force: options.force === true });
+    default:
+      throw new Error(`Unsupported counts snapshot source: ${source}`);
+  }
+}
+
+function buildTodayStatsPayload(source) {
+  switch (source) {
+    case 'claude':
+      return require('./claude-statistics-service').getTodayStatistics();
+    case 'codex':
+      return require('./codex-statistics-service').getTodayStatistics();
+    case 'gemini':
+      return require('./gemini-statistics-service').getTodayStatistics();
+    case 'opencode':
+      return require('./opencode-statistics-service').getTodayStatistics();
+    case 'omp':
+      return require('./omp-statistics-service').getTodayStatistics();
+    default:
+      throw new Error(`Unsupported today stats snapshot source: ${source}`);
+  }
+}
+
+function buildChannelsPayload(source) {
+  switch (source) {
+    case 'claude':
+      return require('./channels').getAllChannels();
+    case 'codex':
+      return require('./codex-channels').getChannels();
+    case 'gemini':
+      return require('./gemini-channels').getChannels();
+    case 'opencode':
+      return require('./opencode-channels').getChannels();
+    case 'omp':
+      return require('./omp-channels').getChannels();
+    default:
+      throw new Error(`Unsupported channels snapshot source: ${source}`);
+  }
+}
+
+async function buildPayload({ kind, source, config, options }) {
+  const snapshotOptions = options || {};
+  switch (kind) {
+    case 'projects':
+      return buildProjectsPayload(source, config || {}, snapshotOptions);
+    case 'counts':
+      return buildCountsPayload(source, config || {}, snapshotOptions);
+    case 'todayStats':
+      return buildTodayStatsPayload(source);
+    case 'channels':
+      return buildChannelsPayload(source);
+    default:
+      throw new Error(`Unsupported dashboard snapshot kind: ${kind}`);
+  }
+}
+
+function runDashboardSnapshotWorker(kind, source, config = {}, options = {}) {
+  if (process.env.NODE_ENV === 'test') {
+    return Promise.resolve(buildPayload({ kind, source, config, options }));
+  }
+
+  return new Promise((resolve, reject) => {
+    const child = fork(__filename, [], {
+      stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
+      env: {
+        ...process.env,
+        CC_TOOL_DASHBOARD_SNAPSHOT_WORKER: '1'
+      }
+    });
+
+    let settled = false;
+    let stderr = '';
+    let timeout = null;
+
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      child.removeAllListeners();
+      if (!child.killed) {
+        child.kill();
+      }
+      if (error) {
+        reject(error);
+      } else {
+        resolve(value);
+      }
+    };
+
+    timeout = setTimeout(() => {
+      finish(new Error(`Dashboard snapshot refresh timed out for ${kind}/${source}`));
+    }, DASHBOARD_SNAPSHOT_WORKER_TIMEOUT_MS);
+
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
+      if (stderr.length > 4096) {
+        stderr = stderr.slice(-4096);
+      }
+    });
+
+    child.on('message', (message) => {
+      if (!message || typeof message !== 'object') return;
+      if (message.ok) {
+        finish(null, message.value);
+      } else {
+        finish(new Error(message.error || `Dashboard snapshot refresh failed for ${kind}/${source}`));
+      }
+    });
+
+    child.on('error', (error) => finish(error));
+    child.on('exit', (code, signal) => {
+      if (settled) return;
+      const suffix = stderr ? `: ${stderr.trim()}` : '';
+      finish(new Error(`Dashboard snapshot worker exited (${code || signal || 'unknown'})${suffix}`));
+    });
+
+    child.send({ kind, source, config, options });
+  });
+}
+
+function attachWorkerHandler() {
+  process.on('message', async (message) => {
+    try {
+      const value = await buildPayload(message || {});
+      if (process.send) {
+        process.send({ ok: true, value }, () => process.exit(0));
+        return;
+      }
+    } catch (error) {
+      if (process.send) {
+        process.send({ ok: false, error: error?.message || String(error) }, () => process.exit(1));
+        return;
+      }
+    }
+    process.exit(0);
+  });
+}
+
+if (process.env.CC_TOOL_DASHBOARD_SNAPSHOT_WORKER === '1' || require.main === module) {
+  attachWorkerHandler();
+}
+
+module.exports = {
+  buildPayload,
+  runDashboardSnapshotWorker
+};

package/src/server/services/gemini-sessions.js

@@ -615,7 +615,11 @@ function normalizeSession(geminiSession) {
  * @param {string} projectHash - 项目 hash
  * @returns {string|null} 项目路径
  */
-function getProjectPath(projectHash) {
+function getProjectPath(projectHash, options = {}) {
+  if (options.force) {
+    pathMappingCache = null;
+    pathMappingCacheTime = 0;
+  }
   const pathMapping = buildPathMapping();
   return pathMapping.get(projectHash) || null;
 }
@@ -624,7 +628,11 @@ function getProjectPath(projectHash) {
  * 聚合项目列表
  * @returns {Array} 项目对象数组
  */
-function getProjects() {
+function getProjects(options = {}) {
+  if (options.force) {
+    pathMappingCache = null;
+    pathMappingCacheTime = 0;
+  }
   const sessions = getAllSessions();
   const projectMap = new Map();
 
@@ -680,7 +688,11 @@ function getProjects() {
  * @param {string} projectHash - 项目 hash
  * @returns {Array} 会话对象数组
  */
-function getProjectSessions(projectHash) {
+function getProjectSessions(projectHash, options = {}) {
+  if (options.force) {
+    pathMappingCache = null;
+    pathMappingCacheTime = 0;
+  }
   const allSessions = getAllSessions();
   return allSessions
     .filter(session => session.projectHash === projectHash)

package/src/server/services/omp-sessions.js

@@ -6,6 +6,8 @@ const { getOmpCommand, getOmpPaths, isOmpInstalled, resolveOmpRuntime } = requir
 
 const PROJECT_ORDER_FILE = PATHS.ompProjectOrder;
 const SESSION_ORDER_FILE = PATHS.ompSessionOrder;
+const OMP_INSTALL_CACHE_TTL_MS = 5 * 60 * 1000;
+let ompInstallCache = { expiresAt: 0, value: false };
 
 function ensureDir(dirPath) {
   if (!fs.existsSync(dirPath)) {
@@ -259,7 +261,7 @@ function loadSessionOrder() {
   return safeReadJson(SESSION_ORDER_FILE, {});
 }
 
-function getProjects() {
+function getProjects(_options = {}) {
   const sessions = getAllSessions();
   const projectMap = new Map();
   sessions.forEach((session) => {
@@ -299,7 +301,7 @@ function getProjects() {
   return projects;
 }
 
-function getSessionsByProject(projectName) {
+function getSessionsByProject(projectName, _options = {}) {
   const orderMap = loadSessionOrder();
   const order = Array.isArray(orderMap[projectName]) ? orderMap[projectName] : [];
   const sessions = getAllSessions().filter(session => session.projectName === projectName);
@@ -425,7 +427,7 @@ function saveSessionOrder(projectName, order) {
   safeWriteJson(SESSION_ORDER_FILE, data);
 }
 
-function getProjectAndSessionCounts() {
+function getProjectAndSessionCounts(_options = {}) {
   const sessions = getAllSessions();
   return {
     projectCount: new Set(sessions.map(session => session.projectName)).size,
@@ -454,15 +456,33 @@ function shellQuote(value) {
 }
 
 function isOmpCliInstalled() {
-  if (isOmpInstalled()) return true;
-  const runtime = resolveOmpRuntime();
-  if (runtime.installed) return true;
-  try {
-    execFileSync(getOmpCommand(), ['--version'], { stdio: 'ignore', timeout: 3000 });
-    return true;
-  } catch {
-    return false;
+  const now = Date.now();
+  if (ompInstallCache.expiresAt > now) {
+    return ompInstallCache.value;
+  }
+
+  let installed = false;
+  if (isOmpInstalled()) {
+    installed = true;
+  } else {
+    const runtime = resolveOmpRuntime();
+    if (runtime.installed) {
+      installed = true;
+    } else {
+      try {
+        execFileSync(getOmpCommand(), ['--version'], { stdio: 'ignore', timeout: 3000 });
+        installed = true;
+      } catch {
+        installed = false;
+      }
+    }
   }
+
+  ompInstallCache = {
+    value: installed,
+    expiresAt: now + OMP_INSTALL_CACHE_TTL_MS
+  };
+  return installed;
 }
 
 module.exports = {

package/src/server/services/opencode-sessions.js

@@ -493,7 +493,7 @@ function getProjectDisplayName(project) {
 }
 
 // 获取所有项目
-function getProjects() {
+function getProjects(_options = {}) {
   const projects = getProjectRows().map((project) => ({
     name: project.id,
     displayName: getProjectDisplayName(project),
@@ -512,7 +512,7 @@ function getProjects() {
 }
 
 // 根据项目ID获取会话列表
-function getSessionsByProjectId(projectId) {
+function getSessionsByProjectId(projectId, _options = {}) {
   const sessions = getSessionRowsByProjectId(projectId).map(session => normalizeSession(session, projectId));
   const order = getSessionOrder(projectId);
 
@@ -536,8 +536,8 @@ function getSessionsByProjectId(projectId) {
 }
 
 // 根据项目名获取会话列表
-function getSessionsByProject(projectName) {
-  return getSessionsByProjectId(projectName);
+function getSessionsByProject(projectName, options = {}) {
+  return getSessionsByProjectId(projectName, options);
 }
 
 function getSessionLocation(sessionId) {
@@ -628,9 +628,12 @@ function getSessionMessages(sessionId) {
 }
 
 // 获取项目和会话数量统计
-function getProjectAndSessionCounts() {
+function getProjectAndSessionCounts(options = {}) {
   const now = Date.now();
-  if (countsCache.expiresAt > now) {
+  if (options.force) {
+    countsCache.expiresAt = 0;
+  }
+  if (!options.force && countsCache.expiresAt > now) {
     return countsCache.value;
   }
 

package/src/server/services/session-snapshot-worker.js

@@ -0,0 +1,158 @@
+'use strict';
+
+const path = require('path');
+
+function totalSizeOf(sessions) {
+  return sessions.reduce((sum, session) => sum + (Number(session.size) || 0), 0);
+}
+
+function getAliases() {
+  const { loadAliases } = require('./alias');
+  return loadAliases();
+}
+
+async function buildClaudePayload(projectName, config, options = {}) {
+  const {
+    getSessionsForProject,
+    parseRealProjectPath
+  } = require('./sessions');
+
+  const result = await getSessionsForProject(config, projectName, { force: options.force === true });
+  const { fullPath, projectName: displayName } = parseRealProjectPath(projectName);
+
+  return {
+    sessions: result.sessions,
+    totalSize: result.totalSize,
+    aliases: getAliases(),
+    projectInfo: {
+      name: projectName,
+      displayName,
+      fullPath
+    }
+  };
+}
+
+function buildCodexPayload(projectName, options = {}) {
+  const { getSessionsByProject } = require('./codex-sessions');
+  const sessions = getSessionsByProject(projectName, { force: options.force === true });
+
+  return {
+    sessions,
+    totalSize: totalSizeOf(sessions),
+    aliases: getAliases(),
+    projectInfo: {
+      name: projectName,
+      fullPath: projectName,
+      path: projectName,
+      displayName: projectName
+    }
+  };
+}
+
+function buildGeminiPayload(projectHash, options = {}) {
+  const { getProjectSessions, getProjectPath } = require('./gemini-sessions');
+  const sessions = getProjectSessions(projectHash, { force: options.force === true });
+  const realPath = getProjectPath(projectHash, { force: options.force === true });
+  const displayName = realPath ? path.basename(realPath) : `Project ${projectHash.substring(0, 8)}`;
+
+  return {
+    sessions,
+    totalSize: totalSizeOf(sessions),
+    aliases: getAliases(),
+    projectInfo: {
+      name: projectHash,
+      fullPath: realPath || projectHash,
+      path: realPath || projectHash,
+      displayName
+    }
+  };
+}
+
+function buildOpenCodePayload(projectName, options = {}) {
+  const { getSessionsByProject, getProjects } = require('./opencode-sessions');
+  const sessions = getSessionsByProject(projectName, { force: options.force === true });
+  const firstDirectory = sessions.find(session => session.directory)?.directory;
+  const project = firstDirectory ? null : getProjects({ force: options.force === true }).find(p => p.name === projectName);
+  const fullPath = firstDirectory || project?.fullPath || projectName;
+
+  return {
+    sessions,
+    totalSize: totalSizeOf(sessions),
+    aliases: getAliases(),
+    projectInfo: {
+      name: projectName,
+      fullPath,
+      path: project?.path || fullPath,
+      displayName: project?.displayName || (fullPath ? path.basename(fullPath) : projectName)
+    }
+  };
+}
+
+function buildOmpPayload(projectName, options = {}) {
+  const { getProjects, getSessionsByProject } = require('./omp-sessions');
+  const sessions = getSessionsByProject(projectName, { force: options.force === true });
+  const firstDirectory = sessions.find(session => session.directory)?.directory;
+  let project = null;
+  try {
+    project = getProjects({ force: options.force === true }).find(p => p.name === projectName) || null;
+  } catch {
+    project = null;
+  }
+  const fullPath = project?.fullPath || project?.path || firstDirectory || projectName;
+
+  return {
+    sessions,
+    totalSize: totalSizeOf(sessions),
+    aliases: getAliases(),
+    projectInfo: {
+      name: projectName,
+      fullPath,
+      path: project?.path || fullPath,
+      displayName: project?.displayName || (fullPath ? path.basename(fullPath) : projectName)
+    }
+  };
+}
+
+async function buildPayload({ source, projectName, config, options }) {
+  const snapshotOptions = options || {};
+  switch (source) {
+    case 'claude':
+      return buildClaudePayload(projectName, config || {}, snapshotOptions);
+    case 'codex':
+      return buildCodexPayload(projectName, snapshotOptions);
+    case 'gemini':
+      return buildGeminiPayload(projectName, snapshotOptions);
+    case 'opencode':
+      return buildOpenCodePayload(projectName, snapshotOptions);
+    case 'omp':
+      return buildOmpPayload(projectName, snapshotOptions);
+    default:
+      throw new Error(`Unsupported session snapshot source: ${source}`);
+  }
+}
+
+function attachWorkerHandler() {
+  process.on('message', async (message) => {
+    try {
+      const value = await buildPayload(message || {});
+      if (process.send) {
+        process.send({ ok: true, value }, () => process.exit(0));
+        return;
+      }
+    } catch (error) {
+      if (process.send) {
+        process.send({ ok: false, error: error?.message || String(error) }, () => process.exit(1));
+        return;
+      }
+    }
+    process.exit(0);
+  });
+}
+
+if (process.env.CC_TOOL_SESSION_SNAPSHOT_WORKER === '1' || require.main === module) {
+  attachWorkerHandler();
+}
+
+module.exports = {
+  buildPayload
+};

package/src/server/services/session-snapshots.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const path = require('path');
+const { fork } = require('child_process');
+const {
+  getSnapshot,
+  invalidateSnapshot
+} = require('./snapshot-cache');
+
+const SESSION_SNAPSHOT_TTL_MS = 60 * 1000;
+const SESSION_SNAPSHOT_DEFER_MS = process.env.NODE_ENV === 'test' ? 0 : 750;
+const SESSION_SNAPSHOT_WORKER_TIMEOUT_MS = 120 * 1000;
+
+function sessionListKey(source, projectName) {
+  return `sessions:list:${source}:${projectName}`;
+}
+
+function defaultProjectInfo(projectName) {
+  return {
+    name: projectName,
+    fullPath: projectName,
+    path: projectName,
+    displayName: projectName
+  };
+}
+
+function emptySessionList(projectName, extra = {}) {
+  return {
+    sessions: [],
+    totalSize: 0,
+    aliases: {},
+    projectInfo: defaultProjectInfo(projectName),
+    ...extra
+  };
+}
+
+function runSessionSnapshotWorker(source, projectName, config = {}, options = {}) {
+  if (process.env.NODE_ENV === 'test') {
+    const { buildPayload } = require('./session-snapshot-worker');
+    return Promise.resolve(buildPayload({ source, projectName, config, options }));
+  }
+
+  return new Promise((resolve, reject) => {
+    const workerPath = path.join(__dirname, 'session-snapshot-worker.js');
+    const child = fork(workerPath, [], {
+      stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
+      env: {
+        ...process.env,
+        CC_TOOL_SESSION_SNAPSHOT_WORKER: '1'
+      }
+    });
+
+    let settled = false;
+    let stderr = '';
+    let timeout = null;
+
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      child.removeAllListeners();
+      if (!child.killed) {
+        child.kill();
+      }
+      if (error) {
+        reject(error);
+      } else {
+        resolve(value);
+      }
+    };
+
+    timeout = setTimeout(() => {
+      finish(new Error(`Session snapshot refresh timed out for ${source}/${projectName}`));
+    }, SESSION_SNAPSHOT_WORKER_TIMEOUT_MS);
+
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
+      if (stderr.length > 4096) {
+        stderr = stderr.slice(-4096);
+      }
+    });
+
+    child.on('message', (message) => {
+      if (!message || typeof message !== 'object') return;
+      if (message.ok) {
+        finish(null, message.value);
+      } else {
+        finish(new Error(message.error || `Session snapshot refresh failed for ${source}/${projectName}`));
+      }
+    });
+
+    child.on('error', (error) => finish(error));
+    child.on('exit', (code, signal) => {
+      if (settled) return;
+      const suffix = stderr ? `: ${stderr.trim()}` : '';
+      finish(new Error(`Session snapshot worker exited (${code || signal || 'unknown'})${suffix}`));
+    });
+
+    child.send({ source, projectName, config, options });
+  });
+}
+
+async function getSessionListSnapshot(source, projectName, {
+  fallbackValue,
+  refresh,
+  force = false
+}) {
+  return getSnapshot(sessionListKey(source, projectName), {
+    ttlMs: SESSION_SNAPSHOT_TTL_MS,
+    fallbackValue: fallbackValue || emptySessionList(projectName),
+    refresh,
+    force: process.env.NODE_ENV === 'test' ? true : force,
+    backgroundOnMiss: process.env.NODE_ENV === 'test' ? false : !force,
+    deferMs: SESSION_SNAPSHOT_DEFER_MS
+  });
+}
+
+function invalidateSessionSnapshots(source, projectName = null) {
+  if (!source) return;
+  if (projectName) {
+    invalidateSnapshot(sessionListKey(source, projectName));
+    return;
+  }
+  invalidateSnapshot(`sessions:list:${source}:`);
+}
+
+module.exports = {
+  SESSION_SNAPSHOT_TTL_MS,
+  defaultProjectInfo,
+  emptySessionList,
+  getSessionListSnapshot,
+  invalidateSessionSnapshots,
+  runSessionSnapshotWorker,
+  sessionListKey
+};

package/src/server/services/sessions.js

@@ -600,12 +600,14 @@ function scanSessionFileForMessagesAsync(filePath) {
 }
 
 // Get sessions for a project - async version
-async function getSessionsForProject(config, projectName) {
+async function getSessionsForProject(config, projectName, options = {}) {
   // Check cache first
   const cacheKey = `${CacheKeys.SESSIONS}${projectName}`;
-  const cached = globalCache.get(cacheKey);
-  if (cached) {
-    return cached;
+  if (!options.force) {
+    const cached = globalCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
   }
 
   const projectConfig = { ...config, currentProject: projectName };