coding-tool-x 3.8.4 → 3.8.6

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

@@ -1,66 +1,225 @@
 'use strict';
 
-const { fork } = require('child_process');
+const childProcess = require('child_process');
 const path = require('path');
 
 const WORKER_TIMEOUT_MS = 180000;
+const MAX_SERIALIZED_ERROR_TEXT_LENGTH = 4096;
+
+function _safeErrorText(value, fallback = '') {
+  const text = value == null || value === '' ? fallback : String(value);
+  return text.length > MAX_SERIALIZED_ERROR_TEXT_LENGTH
+    ? `${text.slice(0, MAX_SERIALIZED_ERROR_TEXT_LENGTH)}…`
+    : text;
+}
+
+function _safeCode(value) {
+  return typeof value === 'string' || typeof value === 'number' ? value : undefined;
+}
+
+const MAX_SERIALIZED_OBJECT_DEPTH = 6;
+const MAX_SERIALIZED_OBJECT_KEYS = 32;
+const MAX_SERIALIZED_ARRAY_LENGTH = 64;
+
+function _safeStructuredValue(value, depth = 0) {
+  if (value == null || typeof value === 'boolean' || typeof value === 'number') {
+    return Number.isFinite(value) || typeof value !== 'number' ? value : undefined;
+  }
+  if (typeof value === 'string') {
+    return _safeErrorText(value);
+  }
+  if (typeof value !== 'object') {
+    return undefined;
+  }
+  if (depth >= MAX_SERIALIZED_OBJECT_DEPTH) {
+    return undefined;
+  }
+  if (Array.isArray(value)) {
+    const items = [];
+    for (const item of value.slice(0, MAX_SERIALIZED_ARRAY_LENGTH)) {
+      const safeItem = _safeStructuredValue(item, depth + 1);
+      if (safeItem !== undefined) {
+        items.push(safeItem);
+      }
+    }
+    return items;
+  }
+
+  const result = {};
+  let count = 0;
+  for (const [key, item] of Object.entries(value)) {
+    if (count >= MAX_SERIALIZED_OBJECT_KEYS) break;
+    const safeItem = _safeStructuredValue(item, depth + 1);
+    if (safeItem !== undefined) {
+      result[_safeErrorText(key)] = safeItem;
+      count += 1;
+    }
+  }
+  return result;
+}
+
+
+
+function _serializeCause(cause) {
+  if (!cause) {
+    return null;
+  }
+  const serialized = {
+    name: _safeErrorText(cause.name, 'Error'),
+    message: _safeErrorText(cause && cause.message ? cause.message : cause, 'Error')
+  };
+  const code = _safeCode(cause.code);
+  if (code !== undefined) {
+    serialized.code = code;
+  }
+  return serialized;
+}
+
+function _serializeWorkerError(error) {
+  if (!error || typeof error !== 'object') {
+    return { message: _safeErrorText(error, 'Inventory worker failed') };
+  }
+  const serialized = {
+    message: _safeErrorText(error.message ? error.message : error, 'Inventory worker failed')
+  };
+  if (typeof error.platform === 'string') serialized.platform = _safeErrorText(error.platform);
+  if (typeof error.capability === 'string') serialized.capability = _safeErrorText(error.capability);
+  if (typeof error.operation === 'string') serialized.operation = _safeErrorText(error.operation);
+  const code = _safeCode(error.code);
+  if (code !== undefined) serialized.code = code;
+  if (typeof error.status === 'string') serialized.status = _safeErrorText(error.status);
+  const failure = _safeStructuredValue(error.failure);
+  if (failure && typeof failure === 'object' && !Array.isArray(failure)) serialized.failure = failure;
+  const context = _safeStructuredValue(error.context);
+  if (context && typeof context === 'object' && !Array.isArray(context)) serialized.context = context;
+  const cause = _serializeCause(error.cause);
+  if (cause) {
+    serialized.cause = cause;
+  }
+  return serialized;
+}
+
+function _deserializeCause(cause) {
+  if (!cause) {
+    return null;
+  }
+  if (cause instanceof Error) {
+    return cause;
+  }
+  const error = new Error(_safeErrorText(cause.message ? cause.message : cause, 'Error'));
+  if (cause.name) {
+    error.name = _safeErrorText(cause.name, 'Error');
+  }
+  const code = _safeCode(cause.code);
+  if (code !== undefined) {
+    error.code = code;
+  }
+  return error;
+}
+
+function _deserializeWorkerError(payload, fallbackMessage = 'Inventory worker failed') {
+  if (payload instanceof Error) {
+    return payload;
+  }
+  if (!payload || typeof payload !== 'object') {
+    return new Error(_safeErrorText(payload, fallbackMessage));
+  }
+  const error = new Error(_safeErrorText(payload.message ? payload.message : fallbackMessage, fallbackMessage));
+  if (typeof payload.platform === 'string') error.platform = _safeErrorText(payload.platform);
+  if (typeof payload.capability === 'string') error.capability = _safeErrorText(payload.capability);
+  if (typeof payload.operation === 'string') error.operation = _safeErrorText(payload.operation);
+  const code = _safeCode(payload.code);
+  if (code !== undefined) error.code = code;
+  if (typeof payload.status === 'string') error.status = _safeErrorText(payload.status);
+  const failure = _safeStructuredValue(payload.failure);
+  if (failure && typeof failure === 'object' && !Array.isArray(failure)) error.failure = failure;
+  const context = _safeStructuredValue(payload.context);
+  if (context && typeof context === 'object' && !Array.isArray(context)) error.context = context;
+  const cause = _deserializeCause(payload.cause);
+  if (cause) {
+    error.cause = cause;
+  }
+  return error;
+}
+
 
 function runInventoryWorker(source, indexDbPath, options = {}) {
   return new Promise((resolve, reject) => {
     const timeoutMs = options.timeoutMs || WORKER_TIMEOUT_MS;
     const workerPath = path.resolve(__dirname, 'session-history-worker.js');
 
-    const child = fork(workerPath, [], {
+    let stderr = '';
+    const child = childProcess.fork(workerPath, [], {
       env: {
         ...process.env,
         CC_TOOL_SESSION_HISTORY_WORKER: '1',
+        CC_TOOL_SESSION_HISTORY_CHILD: '1',
         CC_TOOL_SESSION_HISTORY_SOURCE: source,
         CC_TOOL_SESSION_HISTORY_DB: indexDbPath,
         CC_TOOL_SESSION_HISTORY_FORCE: options.force === true ? '1' : '0',
-        CC_TOOL_SESSION_HISTORY_CHILD: '1'
+        CC_TOOL_SESSION_HISTORY_PROJECTS_DIR: options.projectsDir || ''
       },
       silent: true,
       stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
       windowsHide: true
     });
 
+    if (child.stdout && typeof child.stdout.resume === 'function') {
+      child.stdout.resume();
+    }
+    if (child.stderr) {
+      if (typeof child.stderr.on === 'function') {
+        child.stderr.on('data', (chunk) => {
+          stderr = `${stderr}${chunk.toString()}`.slice(-MAX_SERIALIZED_ERROR_TEXT_LENGTH);
+        });
+      }
+      if (typeof child.stderr.resume === 'function') child.stderr.resume();
+    }
+
     let settled = false;
-    const timer = setTimeout(() => {
+    let timer = null;
+
+    const finish = (error) => {
       if (settled) return;
       settled = true;
-      child.kill('SIGTERM');
-      reject(new Error(`Inventory worker for ${source} timed out after ${timeoutMs}ms`));
+      clearTimeout(timer);
+      child.removeAllListeners();
+      if (!child.killed) {
+        child.kill('SIGTERM');
+      }
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
+    };
+
+    timer = setTimeout(() => {
+      finish(new Error(`Inventory worker for ${source} timed out after ${timeoutMs}ms`));
     }, timeoutMs);
 
     child.on('message', (msg) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
       if (msg && msg.type === 'done') {
-        resolve();
+        finish();
       } else if (msg && msg.type === 'error') {
-        reject(new Error(msg.message || 'Inventory worker failed'));
+        finish(_deserializeWorkerError(msg.error || { message: msg.message }, 'Inventory worker failed'));
       } else {
-        resolve();
+        finish(new Error(`Inventory worker protocol error: unknown message from ${source}`));
       }
     });
 
     child.on('exit', (code) => {
       if (settled) return;
-      settled = true;
-      clearTimeout(timer);
+      const suffix = stderr.trim() ? `: ${stderr.trim()}` : '';
       if (code === 0) {
-        resolve();
+        finish(new Error(`Inventory worker protocol error: exited before done for ${source}${suffix}`));
       } else {
-        reject(new Error(`Inventory worker exited with code ${code}`));
+        finish(new Error(`Inventory worker exited with code ${code}${suffix}`));
       }
     });
 
     child.on('error', (err) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      reject(err);
+      finish(err);
     });
   });
 }
@@ -68,32 +227,68 @@ function runInventoryWorker(source, indexDbPath, options = {}) {
 function attachWorkerHandler() {
   const source = process.env.CC_TOOL_SESSION_HISTORY_SOURCE;
   const dbPath = process.env.CC_TOOL_SESSION_HISTORY_DB;
+  const projectsDir = process.env.CC_TOOL_SESSION_HISTORY_PROJECTS_DIR || undefined;
   const force = process.env.CC_TOOL_SESSION_HISTORY_FORCE === '1';
-
   if (!source || !dbPath) {
     process.exit(1);
+    return;
   }
 
   const { createSessionHistoryIndex } = require('./session-history-index');
-  const index = createSessionHistoryIndex({ dbPath });
+  const index = createSessionHistoryIndex({ dbPath, projectsDir });
+  const finishWorker = (message, exitCode) => {
+    try {
+      index.closeSessionHistoryIndex();
+    } catch (_err) {
+      // The inventory result/error is more useful to the parent than a
+      // best-effort checkpoint failure during worker teardown.
+    }
+    _sendWorkerMessage(message, exitCode);
+  };
 
   index.ensureSourceIndexed(source, { consistency: 'complete', force })
-    .then(() => {
-      if (process.send) {
-        process.send({ type: 'done' });
-      }
-      process.exit(0);
-    })
-    .catch((err) => {
-      if (process.send) {
-        process.send({ type: 'error', message: err.message });
+    .then(() => finishWorker({ type: 'done' }, 0))
+    .catch((err) => finishWorker({ type: 'error', error: _serializeWorkerError(err) }, 1));
+}
+
+function _sendWorkerMessage(message, exitCode, send, exit = process.exit) {
+  let exited = false;
+  const finish = (code) => {
+    if (exited) return;
+    exited = true;
+    exit(code);
+  };
+
+  const sendImpl = send || (typeof process.send === 'function' ? process.send.bind(process) : null);
+  if (!sendImpl) {
+    finish(exitCode);
+    return;
+  }
+
+  try {
+    sendImpl(message, (callbackError) => {
+      if (callbackError) {
+        finish(exitCode || 1);
+        return;
       }
-      process.exit(1);
+      finish(exitCode);
     });
+  } catch (_error) {
+    finish(exitCode || 1);
+  }
 }
 
 if (process.env.CC_TOOL_SESSION_HISTORY_WORKER === '1' || require.main === module) {
   attachWorkerHandler();
 }
 
-module.exports = { runInventoryWorker };
+module.exports = {
+  runInventoryWorker,
+  attachWorkerHandler,
+  _test: {
+    serializeWorkerError: _serializeWorkerError,
+    deserializeWorkerError: _deserializeWorkerError,
+    sendWorkerMessage: _sendWorkerMessage,
+    createSessionHistoryIndex: (...args) => require('./session-history-index').createSessionHistoryIndex(...args)
+  }
+};

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

@@ -1,6 +1,36 @@
 'use strict';
 
 const path = require('path');
+const { getPlatformContext } = require('../platform-context');
+
+function invokeSessionDriver(platform, capability, operation, args = [], runtime = null) {
+  const resolvedRuntime = runtime || getPlatformContext().runtime;
+  const driver = resolvedRuntime?.getDriver?.(platform, capability);
+  if (!driver || typeof driver[operation] !== 'function') {
+    const error = new Error(`平台 ${platform} 未声明 ${capability}.${operation} capability`);
+    error.status = 404;
+    error.code = 'unsupported';
+    error.platform = platform;
+    error.capability = capability;
+    error.operation = operation;
+    throw error;
+  }
+  const result = driver[operation](...args);
+  const unwrap = value => {
+    if (!value || typeof value !== 'object' || !value.status) return value;
+    if (value.status === 'ok') return value.data;
+    if (value.cause instanceof Error) throw value.cause;
+    const error = new Error(value.error || `平台 ${platform} 的 ${capability}.${operation} 失败`);
+    Object.assign(error, {
+      status: value.status,
+      platform: value.platform || platform,
+      capability: value.capability || capability,
+      operation: value.operation || operation
+    });
+    throw error;
+  };
+  return result && typeof result.then === 'function' ? result.then(unwrap) : unwrap(result);
+}
 
 function totalSizeOf(sessions) {
   return sessions.reduce((sum, session) => sum + (Number(session.size) || 0), 0);
@@ -11,14 +41,30 @@ function getAliases() {
   return loadAliases();
 }
 
-async function buildClaudePayload(projectName, config, options = {}) {
-  const {
-    getSessionsForProject,
-    parseRealProjectPath
-  } = require('./sessions');
+function indexedReadOptions(options = {}, config) {
+  const force = options.force === true;
+  return {
+    force,
+    ...(force ? { consistency: 'complete' } : {}),
+    ...(config ? { config } : {})
+  };
+}
 
-  const result = await getSessionsForProject(config, projectName, { force: options.force === true });
-  const { fullPath, projectName: displayName } = parseRealProjectPath(projectName);
+async function buildClaudePayload(projectName, config, options = {}, runtime = null) {
+  const result = await invokeSessionDriver(
+    'claude',
+    'sessions',
+    'listSessions',
+    [projectName, indexedReadOptions(options, config)],
+    runtime
+  );
+  const { fullPath, projectName: displayName } = invokeSessionDriver(
+    'claude',
+    'sessions',
+    'parseRealProjectPath',
+    [projectName],
+    runtime
+  );
 
   return {
     sessions: result.sessions,
@@ -32,9 +78,15 @@ async function buildClaudePayload(projectName, config, options = {}) {
   };
 }
 
-async function buildCodexPayload(projectName, options = {}) {
-  const { getSessionsByProject } = require('./codex-sessions');
-  const sessions = await getSessionsByProject(projectName, { force: options.force === true });
+async function buildCodexPayload(projectName, options = {}, runtime = null) {
+  const sessions = await invokeSessionDriver(
+    'codex',
+    'sessions',
+    'listSessions',
+    [projectName, indexedReadOptions(options)],
+    runtime
+  );
+  const projectFullPath = sessions.find(session => session.projectFullPath)?.projectFullPath || projectName;
 
   return {
     sessions,
@@ -42,18 +94,31 @@ async function buildCodexPayload(projectName, options = {}) {
     aliases: getAliases(),
     projectInfo: {
       name: projectName,
-      fullPath: projectName,
-      path: projectName,
+      fullPath: projectFullPath,
+      path: projectFullPath,
       displayName: projectName
     }
   };
 }
 
-async function buildGeminiPayload(projectHash, options = {}) {
-  const { getProjectSessions, getProjectPath } = require('./gemini-sessions');
-  const sessions = await 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)}`;
+async function buildGeminiPayload(projectHash, options = {}, runtime = null) {
+  const sessions = await invokeSessionDriver(
+    'gemini',
+    'sessions',
+    'listSessions',
+    [projectHash, indexedReadOptions(options)],
+    runtime
+  );
+  const realPath = await invokeSessionDriver(
+    'gemini',
+    'sessions',
+    'getProjectPath',
+    [projectHash, indexedReadOptions(options)],
+    runtime
+  );
+  const indexedPath = sessions.find(session => session.projectRoot || session.projectFullPath);
+  const fullPath = realPath || indexedPath?.projectRoot || indexedPath?.projectFullPath || projectHash;
+  const displayName = fullPath !== projectHash ? path.basename(fullPath) : `Project ${projectHash.substring(0, 8)}`;
 
   return {
     sessions,
@@ -61,19 +126,33 @@ async function buildGeminiPayload(projectHash, options = {}) {
     aliases: getAliases(),
     projectInfo: {
       name: projectHash,
-      fullPath: realPath || projectHash,
-      path: realPath || projectHash,
+      fullPath,
+      path: fullPath,
       displayName
     }
   };
 }
 
-function buildOpenCodePayload(projectName, options = {}) {
-  const { getSessionsByProject, getProjects } = require('./opencode-sessions');
-  const sessions = getSessionsByProject(projectName, { force: options.force === true });
+async function buildOpenCodePayload(projectName, options = {}, runtime = null) {
+  const sessions = await invokeSessionDriver(
+    'opencode',
+    'sessions',
+    'listSessions',
+    [projectName, indexedReadOptions(options)],
+    runtime
+  );
+  const projects = await invokeSessionDriver(
+    'opencode',
+    'sessions',
+    'getProjects',
+    [indexedReadOptions(options)],
+    runtime
+  );
   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;
+  const project = projects.find(p => p.name === projectName) || null;
+  const projectPath = [project?.fullPath, project?.path]
+    .find(value => value && value !== '/');
+  const fullPath = projectPath || firstDirectory || project?.fullPath || project?.path || projectName;
 
   return {
     sessions,
@@ -88,13 +167,24 @@ function buildOpenCodePayload(projectName, options = {}) {
   };
 }
 
-async function buildOmpPayload(projectName, options = {}) {
-  const { getProjects, getSessionsByProject } = require('./omp-sessions');
-  const sessions = await getSessionsByProject(projectName, { force: options.force === true });
+async function buildOmpPayload(projectName, options = {}, runtime = null) {
+  const sessions = await invokeSessionDriver(
+    'omp',
+    'sessions',
+    'listSessions',
+    [projectName, indexedReadOptions(options)],
+    runtime
+  );
   const firstDirectory = sessions.find(session => session.directory)?.directory;
   let project = null;
   try {
-    project = (await getProjects({ force: options.force === true })).find(p => p.name === projectName) || null;
+    project = (await invokeSessionDriver(
+      'omp',
+      'sessions',
+      'getProjects',
+      [indexedReadOptions(options)],
+      runtime
+    )).find(p => p.name === projectName) || null;
   } catch {
     project = null;
   }
@@ -113,19 +203,19 @@ async function buildOmpPayload(projectName, options = {}) {
   };
 }
 
-async function buildPayload({ source, projectName, config, options }) {
+async function buildPayload({ source, projectName, config, options, runtime }) {
   const snapshotOptions = options || {};
   switch (source) {
     case 'claude':
-      return buildClaudePayload(projectName, config || {}, snapshotOptions);
+      return buildClaudePayload(projectName, config || {}, snapshotOptions, runtime);
     case 'codex':
-      return buildCodexPayload(projectName, snapshotOptions);
+      return buildCodexPayload(projectName, snapshotOptions, runtime);
     case 'gemini':
-      return buildGeminiPayload(projectName, snapshotOptions);
+      return buildGeminiPayload(projectName, snapshotOptions, runtime);
     case 'opencode':
-      return buildOpenCodePayload(projectName, snapshotOptions);
+      return buildOpenCodePayload(projectName, snapshotOptions, runtime);
     case 'omp':
-      return buildOmpPayload(projectName, snapshotOptions);
+      return buildOmpPayload(projectName, snapshotOptions, runtime);
     default:
       throw new Error(`Unsupported session snapshot source: ${source}`);
   }

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

@@ -4,7 +4,8 @@ const path = require('path');
 const { fork } = require('child_process');
 const {
   getSnapshot,
-  invalidateSnapshot
+  invalidateSnapshot,
+  invalidateDashboardSourceSnapshot
 } = require('./snapshot-cache');
 
 const SESSION_SNAPSHOT_TTL_MS = 60 * 1000;
@@ -122,14 +123,15 @@ async function getSessionListSnapshot(source, projectName, {
     deferMs: SESSION_SNAPSHOT_DEFER_MS
   });
 }
-
 function invalidateSessionSnapshots(source, projectName = null) {
   if (!source) return;
   if (projectName) {
     invalidateSnapshot(sessionListKey(source, projectName));
+    invalidateDashboardSourceSnapshot(source);
     return;
   }
   invalidateSnapshot(`sessions:list:${source}:`);
+  invalidateDashboardSourceSnapshot(source);
 }
 
 module.exports = {