coding-tool-x 3.8.3 → 3.8.5

package/src/server/services/ui-config.js

@@ -1,15 +1,16 @@
+'use strict';
+
 const fs = require('fs');
 const path = require('path');
 const { PATHS } = require('../../config/paths');
 const {
-  DEFAULT_HOME_CLI_COLUMNS,
-  normalizeCustomCliPlatforms,
-  normalizeHomeCliColumns
+  DEFAULT_ENABLED_CLI_PLATFORMS,
+  migrateLegacyCliConfig
 } = require('../../shared/platforms');
 
 const UI_CONFIG_FILE = PATHS.uiConfig;
+const OPTIONAL_UI_CONFIG_FIELDS = ['remoteNotifications', 'claudeNotificationDisabledByUser'];
 
-// Default UI config
 const DEFAULT_UI_CONFIG = {
   theme: 'light',
   panelVisibility: {
@@ -40,128 +41,158 @@ const DEFAULT_UI_CONFIG = {
     opencode: [],
     omp: []
   },
-  dashboardChannelOrder: DEFAULT_HOME_CLI_COLUMNS,
-  homeCliColumns: DEFAULT_HOME_CLI_COLUMNS,
-  customCliPlatforms: []
+  enabledCliPlatforms: DEFAULT_ENABLED_CLI_PLATFORMS
 };
 
-// 内存缓存
 let uiConfigCache = null;
 let cacheInitialized = false;
+let watcherInitialized = false;
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
 
-// Ensure UI config directory exists
 function ensureConfigDir() {
   const dir = path.dirname(UI_CONFIG_FILE);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function getAllowedPlatformKeys() {
+  // Keep this require lazy: runtime's registry construction reads configuration.
+  try {
+    const { registry } = require('../platform-context').getPlatformContext();
+    const platforms = registry && typeof registry.list === 'function' ? registry.list() : [];
+    const keys = platforms
+      .map(platform => String(platform && platform.key || '').trim().toLowerCase())
+      .filter(Boolean);
+    return keys.length ? keys : [...DEFAULT_ENABLED_CLI_PLATFORMS];
+  } catch (error) {
+    return [...DEFAULT_ENABLED_CLI_PLATFORMS];
+  }
+}
+
+function normalizeUIConfig(config = {}) {
+  const source = config && typeof config === 'object' && !Array.isArray(config) ? config : {};
+  const allowedKeys = getAllowedPlatformKeys();
+  const migrationInput = {
+    homeCliColumns: source.homeCliColumns,
+    dashboardChannelOrder: source.dashboardChannelOrder,
+    customCliPlatforms: source.customCliPlatforms,
+    allowedKeys,
+    fallback: DEFAULT_ENABLED_CLI_PLATFORMS
+  };
+  if (Object.prototype.hasOwnProperty.call(source, 'enabledCliPlatforms')) {
+    migrationInput.enabledCliPlatforms = source.enabledCliPlatforms;
+  }
+  const enabledCliPlatforms = migrateLegacyCliConfig(migrationInput);
+
+  const normalized = {
+    theme: source.theme || DEFAULT_UI_CONFIG.theme,
+    panelVisibility: { ...DEFAULT_UI_CONFIG.panelVisibility, ...(source.panelVisibility || {}) },
+    channelBalance: { ...DEFAULT_UI_CONFIG.channelBalance, ...(source.channelBalance || {}) },
+    channelLocks: { ...DEFAULT_UI_CONFIG.channelLocks, ...(source.channelLocks || {}) },
+    channelCollapse: { ...DEFAULT_UI_CONFIG.channelCollapse, ...(source.channelCollapse || {}) },
+    channelOrder: { ...DEFAULT_UI_CONFIG.channelOrder, ...(source.channelOrder || {}) },
+    enabledCliPlatforms
+  };
+  for (const field of OPTIONAL_UI_CONFIG_FIELDS) {
+    if (Object.prototype.hasOwnProperty.call(source, field)) normalized[field] = clone(source[field]);
+  }
+  return clone(normalized);
+}
+
+function writeCanonicalConfig(config) {
+  ensureConfigDir();
+  const temporaryFile = path.join(
+    path.dirname(UI_CONFIG_FILE),
+    `.${path.basename(UI_CONFIG_FILE)}.${process.pid}.${Date.now()}.tmp`
+  );
+  try {
+    fs.writeFileSync(temporaryFile, JSON.stringify(config, null, 2), 'utf8');
+    fs.renameSync(temporaryFile, UI_CONFIG_FILE);
+  } catch (error) {
+    try { fs.unlinkSync(temporaryFile); } catch { /* best effort cleanup */ }
+    throw error;
   }
 }
 
-// 从文件读取并缓存
 function readUIConfigFromFile() {
   ensureConfigDir();
 
-  if (!fs.existsSync(UI_CONFIG_FILE)) {
-    return { ...DEFAULT_UI_CONFIG };
-  }
+  if (!fs.existsSync(UI_CONFIG_FILE)) return clone(DEFAULT_UI_CONFIG);
 
+  let data;
   try {
     const content = fs.readFileSync(UI_CONFIG_FILE, 'utf8');
-    const data = JSON.parse(content);
-    // Merge with defaults to ensure all keys exist
-    return normalizeUIConfig({
-      ...DEFAULT_UI_CONFIG,
-      ...data,
-      theme: data.theme || DEFAULT_UI_CONFIG.theme,
-      panelVisibility: { ...DEFAULT_UI_CONFIG.panelVisibility, ...data.panelVisibility },
-      channelBalance: { ...DEFAULT_UI_CONFIG.channelBalance, ...data.channelBalance },
-      channelLocks: { ...DEFAULT_UI_CONFIG.channelLocks, ...data.channelLocks },
-      channelCollapse: { ...DEFAULT_UI_CONFIG.channelCollapse, ...data.channelCollapse },
-      channelOrder: { ...DEFAULT_UI_CONFIG.channelOrder, ...data.channelOrder }
-    });
+    data = JSON.parse(content);
+    if (!data || typeof data !== 'object' || Array.isArray(data)) throw new Error('UI config must be an object');
   } catch (error) {
     console.error('Error loading UI config:', error);
-    return normalizeUIConfig({ ...DEFAULT_UI_CONFIG });
+    return normalizeUIConfig({});
   }
-}
 
-function normalizeUIConfig(config = {}) {
-  const customCliPlatforms = normalizeCustomCliPlatforms(config.customCliPlatforms);
-  const legacyOrder = Array.isArray(config.homeCliColumns)
-    ? config.homeCliColumns
-    : config.dashboardChannelOrder;
-  const homeCliColumns = normalizeHomeCliColumns(legacyOrder, customCliPlatforms);
-
-  return {
-    ...DEFAULT_UI_CONFIG,
-    ...config,
-    panelVisibility: { ...DEFAULT_UI_CONFIG.panelVisibility, ...(config.panelVisibility || {}) },
-    channelBalance: { ...DEFAULT_UI_CONFIG.channelBalance, ...(config.channelBalance || {}) },
-    channelLocks: { ...DEFAULT_UI_CONFIG.channelLocks, ...(config.channelLocks || {}) },
-    channelCollapse: { ...DEFAULT_UI_CONFIG.channelCollapse, ...(config.channelCollapse || {}) },
-    channelOrder: { ...DEFAULT_UI_CONFIG.channelOrder, ...(config.channelOrder || {}) },
-    dashboardChannelOrder: homeCliColumns,
-    homeCliColumns,
-    customCliPlatforms
-  };
+  const normalized = normalizeUIConfig(data);
+  if (JSON.stringify(data) !== JSON.stringify(normalized)) {
+    try {
+      writeCanonicalConfig(normalized);
+    } catch (error) {
+      console.error('Error rewriting UI config:', error);
+    }
+  }
+  return normalized;
 }
 
-// 初始化缓存（延迟初始化）
-function initializeCache() {
-  if (cacheInitialized) return;
-  uiConfigCache = readUIConfigFromFile();
-  cacheInitialized = true;
-
-  // 监听文件变化，更新缓存
+function installConfigWatcher() {
+  if (watcherInitialized) return;
   try {
     fs.watchFile(UI_CONFIG_FILE, { persistent: false }, () => {
       uiConfigCache = readUIConfigFromFile();
     });
+    watcherInitialized = true;
   } catch (err) {
     console.error('Failed to watch UI config file:', err);
   }
 }
 
-// Load UI config（使用缓存）
+function initializeCache() {
+  if (cacheInitialized) return;
+  uiConfigCache = readUIConfigFromFile();
+  cacheInitialized = true;
+  installConfigWatcher();
+}
+
 function loadUIConfig() {
-  if (!cacheInitialized) {
-    initializeCache();
-  }
-  return JSON.parse(JSON.stringify(uiConfigCache)); // 深拷贝返回
+  if (!cacheInitialized) initializeCache();
+  return clone(uiConfigCache);
 }
 
-// Save UI config（同时更新缓存）
 function saveUIConfig(config) {
-  ensureConfigDir();
-
   try {
-    const normalizedConfig = normalizeUIConfig(config);
-    fs.writeFileSync(UI_CONFIG_FILE, JSON.stringify(normalizedConfig, null, 2), 'utf8');
-    // 同时更新缓存
-    uiConfigCache = JSON.parse(JSON.stringify(normalizedConfig));
+    const currentConfig = loadUIConfig();
+    const source = config && typeof config === 'object' && !Array.isArray(config) ? config : {};
+    const normalizedConfig = normalizeUIConfig({ ...currentConfig, ...source });
+    writeCanonicalConfig(normalizedConfig);
+    uiConfigCache = clone(normalizedConfig);
+    cacheInitialized = true;
+    installConfigWatcher();
+    return clone(normalizedConfig);
   } catch (error) {
     console.error('Error saving UI config:', error);
     throw error;
   }
 }
 
-// Update specific config key
 function updateUIConfig(key, value) {
   const config = loadUIConfig();
   config[key] = value;
-  saveUIConfig(config);
-  return loadUIConfig();
+  return saveUIConfig(config);
 }
 
-// Update nested config
 function updateNestedUIConfig(parentKey, childKey, value) {
   const config = loadUIConfig();
-  if (!config[parentKey]) {
-    config[parentKey] = {};
-  }
+  if (!config[parentKey] || typeof config[parentKey] !== 'object') config[parentKey] = {};
   config[parentKey][childKey] = value;
-  saveUIConfig(config);
-  return loadUIConfig();
+  return saveUIConfig(config);
 }
 
 module.exports = {

package/src/server/services/usage-log-utils.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const { normalizeUsage: normalizeNativeUsage } = require('../../platforms/drivers/native-log-utils');
+const { resolveModelPricing, calculateTokenCost } = require('../utils/pricing');
+
+function toNumber(value) {
+  const num = Number(value);
+  return Number.isFinite(num) ? num : 0;
+}
+
+function normalizeToolSource(source = '') {
+  const normalized = String(source || '').trim().toLowerCase();
+  if (normalized === 'claude' || normalized === 'claude-code') return 'claude';
+  if (normalized === 'codex') return 'codex';
+  if (normalized === 'gemini') return 'gemini';
+  if (normalized === 'opencode') return 'opencode';
+  if (normalized === 'omp' || normalized === 'omp-agent') return 'omp';
+  return 'claude';
+}
+
+function normalizeModelName(value = '') {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function resolveActualModel(model = '', metadata = {}) {
+  const candidates = [model, metadata.redirectedModel, metadata.modelFromUrl, metadata.requestModel, metadata.model, metadata.originalModel];
+  for (const candidate of candidates) {
+    const normalized = normalizeModelName(candidate);
+    if (normalized) return normalized;
+  }
+  return '';
+}
+
+function normalizeUsageTokens(source, tokens = {}) {
+  const normalizedSource = normalizeToolSource(source);
+  const normalizedUsage = normalizeNativeUsage(tokens);
+  const input = toNumber(normalizedUsage.input);
+  const output = toNumber(normalizedUsage.output);
+  const cacheCreation = toNumber(normalizedUsage.cacheCreation);
+  const cacheRead = toNumber(normalizedUsage.cacheRead || normalizedUsage.cached);
+  const cached = toNumber(normalizedUsage.cached || cacheRead);
+  const reasoning = toNumber(normalizedUsage.reasoning);
+  const hasPositiveReportedTotal = ['total', 'total_tokens', 'totalTokens', 'totalTokenCount']
+    .some(key => toNumber(tokens?.[key]) > 0);
+  let total = toNumber(normalizedUsage.total);
+  if (!hasPositiveReportedTotal) {
+    if (normalizedSource === 'claude') {
+      total = input + output + cacheCreation + cacheRead;
+    } else if (normalizedSource === 'gemini') {
+      total = input + output + cacheCreation + cacheRead + reasoning;
+    }
+  }
+  return { input, output, cacheCreation, cacheRead, cached, reasoning, total };
+}
+
+function hasMeaningfulUsage(source, tokens = {}) {
+  const normalized = normalizeUsageTokens(source, tokens);
+  return normalized.total > 0 || normalized.input > 0 || normalized.output > 0
+    || normalized.cacheCreation > 0 || normalized.cacheRead > 0
+    || normalized.cached > 0 || normalized.reasoning > 0;
+}
+
+function calculateUsageCost(source, model, tokens = {}) {
+  const normalizedSource = normalizeToolSource(source);
+  const pricing = resolveModelPricing(normalizedSource, model);
+  return calculateTokenCost(pricing, normalizeUsageTokens(normalizedSource, tokens), {
+    reasoningBilledAsOutput: normalizedSource === 'gemini'
+  });
+}
+
+function formatRealtimeTime(timestamp = Date.now()) {
+  return new Date(timestamp).toLocaleTimeString('zh-CN', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' });
+}
+
+function buildSuccessLogPayload({ source, requestId, channel, model, originalModel, redirectedModel, tokens, cost = 0, timestamp = Date.now(), usageMissing = false }) {
+  const normalized = normalizeUsageTokens(source, tokens);
+  const payload = {
+    type: 'log', status: 'success', id: requestId, time: formatRealtimeTime(timestamp), channel,
+    model: model || '', inputTokens: normalized.input, outputTokens: normalized.output,
+    cacheCreation: normalized.cacheCreation, cacheRead: normalized.cacheRead, cachedTokens: normalized.cached,
+    reasoningTokens: normalized.reasoning, totalTokens: normalized.total, cost,
+    source: normalizeToolSource(source), timestamp, usageMissing: Boolean(usageMissing)
+  };
+  if (originalModel) payload.originalModel = originalModel;
+  if (redirectedModel) payload.redirectedModel = redirectedModel;
+  return payload;
+}
+
+module.exports = {
+  toNumber,
+  normalizeToolSource,
+  resolveActualModel,
+  normalizeUsageTokens,
+  hasMeaningfulUsage,
+  calculateUsageCost,
+  formatRealtimeTime,
+  buildSuccessLogPayload
+};

package/src/server/services/web-build.js

@@ -6,7 +6,7 @@ const { spawn } = require('child_process');
 
 const DEFAULT_PROJECT_ROOT = path.resolve(__dirname, '../../..');
 const IGNORED_DIR_NAMES = new Set(['node_modules', '.git', 'dist']);
-const WATCHED_WEB_FILES = ['index.html', 'package.json', 'package-lock.json', 'pnpm-lock.yaml', 'vite.config.js'];
+const WATCHED_WEB_FILES = ['index.html', 'package.json', 'package-lock.json', 'vite.config.js'];
 const WATCHED_WEB_DIRS = ['src', 'public'];
 
 function pathExists(targetPath) {

package/src/server/services/workspace-service.js

@@ -348,7 +348,7 @@ function getGitWorktrees(repoPath) {
  * @param {string} options.baseDir - 基础目录（可选）
  * @param {Array} options.projects - 项目列表 [{sourcePath, name, createWorktree, branch}]
  */
-function createWorkspace(options) {
+async function createWorkspace(options) {
   const { name, description = '', baseDir, projects = [], configTemplateId } = options;
 
   if (!name || name.trim() === '') {
@@ -501,23 +501,6 @@ function createWorkspace(options) {
       });
     }
 
-    // 应用配置模板（如果指定）
-    let templateInfo = null;
-    if (configTemplateId) {
-      try {
-        const result = configTemplatesService.applyTemplate(workspacePath, configTemplateId);
-        templateInfo = {
-          templateId: configTemplateId,
-          templateName: result.template,
-          appliedAt: new Date().toISOString()
-        };
-      } catch (templateError) {
-        console.warn('应用配置模板失败:', templateError.message);
-        // 不中断工作区创建流程
-      }
-    }
-
-    // 保存工作区配置
     const workspaceId = generateWorkspaceId();
     const workspace = {
       id: workspaceId,
@@ -525,17 +508,64 @@ function createWorkspace(options) {
       description,
       path: workspacePath,
       projects: workspaceProjects,
-      configTemplate: templateInfo,
+      configTemplate: null,
       createdAt: new Date().toISOString(),
       lastUsed: new Date().toISOString()
     };
 
     const data = loadWorkspaces();
     data.workspaces.push(workspace);
-    saveWorkspaces(data);
+    if (!saveWorkspaces(data)) {
+      throw new Error('保存工作区配置失败');
+    }
+    let workspaceRegistered = true;
+
+    try {
+      // 应用配置模板（如果指定）
+      if (configTemplateId) {
+        try {
+          const result = await configTemplatesService.applyTemplate(workspacePath, configTemplateId);
+          workspace.configTemplate = {
+            templateId: configTemplateId,
+            templateName: result.template,
+            appliedAt: new Date().toISOString()
+          };
+        } catch (templateError) {
+          console.warn('应用配置模板失败:', templateError.message);
+          // 不中断工作区创建流程
+        }
+      }
 
-    return workspace;
+      if (!saveWorkspaces(data)) {
+        throw new Error('保存工作区配置失败');
+      }
+      return workspace;
+    } catch (error) {
+      if (workspaceRegistered) {
+        const current = loadWorkspaces();
+        const index = current.workspaces.findIndex(item => item.id === workspaceId);
+        if (index !== -1 && !saveWorkspaces({
+          ...current,
+          workspaces: current.workspaces.filter(item => item.id !== workspaceId)
+        })) {
+          console.error('回滚工作区配置失败:', workspaceId);
+        }
+        workspaceRegistered = false;
+      }
+      throw error;
+    }
   } catch (error) {
+    for (const project of workspaceProjects) {
+      if (!project.useWorktree || !project.sourcePath || !project.targetPath) continue;
+      try {
+        runGitCommand(['worktree', 'remove', project.targetPath, '--force'], {
+          cwd: project.sourcePath
+        });
+      } catch (cleanupError) {
+        console.error(`注销 worktree 失败: ${project.targetPath}`, cleanupError.message);
+      }
+    }
+
     // 清理已创建的目录
     try {
       if (fs.existsSync(workspacePath)) {
@@ -732,14 +762,14 @@ function removeProjectFromWorkspace(workspaceId, projectName) {
  */
 async function getAllAvailableProjects() {
   const { loadConfig } = require('../../config/loader');
-  const sessionsService = require('./sessions');
-  const codexSessionsService = require('./codex-sessions');
-  const geminiSessionsService = require('./gemini-sessions');
-  const opencodeSessionsService = require('./opencode-sessions');
-  const ompSessionsService = require('./omp-sessions');
-  const { isCodexInstalled } = require('./codex-config');
-  const { isGeminiInstalled } = require('./gemini-config');
-  const { isOpenCodeInstalled } = require('./opencode-sessions');
+  const sessionsService = require('../../platforms/drivers/claude/sessions-implementation');
+  const codexSessionsService = require('../../platforms/drivers/codex/sessions-implementation');
+  const geminiSessionsService = require('../../platforms/drivers/gemini/sessions-implementation');
+  const opencodeSessionsService = require('../../platforms/drivers/opencode/sessions-implementation');
+  const ompSessionsService = require('../../platforms/drivers/omp/sessions-implementation');
+  const { isCodexInstalled } = require('../../platforms/drivers/codex/config');
+  const { isGeminiInstalled } = require('../../platforms/drivers/gemini/config');
+  const { isOpenCodeInstalled } = require('../../platforms/drivers/opencode/sessions-implementation');
 
   const allProjects = [];
   const seenKeys = new Set();

package/src/server/utils/pricing.js

@@ -54,32 +54,24 @@ function resolveMetadataPricing(model) {
   }
 }
 
-function resolvePricing(_toolKey, modelPricing = {}, defaultPricing = {}) {
-  return { ...defaultPricing, ...(modelPricing || {}) };
-}
-
-function resolveModelPricing(_toolKey, model, fallbackPricing = {}, defaultPricing = {}) {
+function resolveModelPricing(_toolKey, model) {
   const pricingFromMetadata = resolveMetadataPricing(model);
-  return {
-    ...defaultPricing,
-    ...(fallbackPricing || {}),
-    ...(pricingFromMetadata || {})
-  };
+  return pricingFromMetadata ? { ...pricingFromMetadata } : {};
 }
 
-function getRate(pricing, defaultPricing, key) {
+function getRate(pricing, key) {
   if (typeof pricing?.[key] === 'number') return pricing[key];
-  if (typeof defaultPricing?.[key] === 'number') return defaultPricing[key];
   return 0;
 }
 
-function calculateTokenCost(pricing = {}, tokens = {}, defaultPricing = {}) {
-  const inputRate = getRate(pricing, defaultPricing, 'input');
-  const outputRate = getRate(pricing, defaultPricing, 'output');
-  const cacheCreationRate = getRate(pricing, defaultPricing, 'cacheCreation');
-  const cacheReadRate = getRate(pricing, defaultPricing, 'cacheRead');
+function calculateTokenCost(pricing = {}, tokens = {}, options = {}) {
+  const inputRate = getRate(pricing, 'input');
+  const outputRate = getRate(pricing, 'output');
+  const cacheCreationRate = getRate(pricing, 'cacheCreation');
+  const cacheReadRate = getRate(pricing, 'cacheRead');
   const inputTokens = Number(tokens.input || 0);
-  const outputTokens = Number(tokens.output || 0);
+  const outputTokens = Number(tokens.output || 0)
+    + (options.reasoningBilledAsOutput ? Number(tokens.reasoning || 0) : 0);
   const cacheCreationTokens = Number(tokens.cacheCreation || 0);
   const cacheReadTokens = Number(tokens.cacheRead || tokens.cached || 0);
 
@@ -92,7 +84,6 @@ function calculateTokenCost(pricing = {}, tokens = {}, defaultPricing = {}) {
 }
 
 module.exports = {
-  resolvePricing,
   resolveModelPricing,
   calculateTokenCost
 };