coding-tool-x 3.2.0

package/src/server/services/gemini-settings-manager.js

@@ -0,0 +1,263 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Gemini 配置文件路径
+function getEnvPath() {
+  return path.join(os.homedir(), '.gemini', '.env');
+}
+
+function getSettingsPath() {
+  return path.join(os.homedir(), '.gemini', 'settings.json');
+}
+
+// 备份文件路径
+function getEnvBackupPath() {
+  return path.join(os.homedir(), '.gemini', '.env.cc-tool-backup');
+}
+
+function getSettingsBackupPath() {
+  return path.join(os.homedir(), '.gemini', 'settings.json.cc-tool-backup');
+}
+
+// 检查配置文件是否存在
+function configExists() {
+  return fs.existsSync(getEnvPath());
+}
+
+function settingsExists() {
+  return fs.existsSync(getSettingsPath());
+}
+
+// 检查是否已经有备份
+function hasBackup() {
+  return fs.existsSync(getEnvBackupPath()) || fs.existsSync(getSettingsBackupPath());
+}
+
+// 读取 .env
+function readEnv() {
+  try {
+    const content = fs.readFileSync(getEnvPath(), 'utf8');
+    const env = {};
+
+    content.split('\n').forEach(line => {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) return;
+
+      const match = trimmed.match(/^([^=]+)=(.*)$/);
+      if (match) {
+        env[match[1].trim()] = match[2].trim();
+      }
+    });
+
+    return env;
+  } catch (err) {
+    throw new Error('Failed to read .env: ' + err.message);
+  }
+}
+
+// 将环境对象转换为 .env 字符串
+function envToString(env) {
+  let content = '';
+  for (const [key, value] of Object.entries(env)) {
+    content += `${key}=${value}\n`;
+  }
+  return content;
+}
+
+// 写入 .env
+function writeEnv(env) {
+  try {
+    const content = envToString(env);
+    fs.writeFileSync(getEnvPath(), content, 'utf8');
+
+    // 设置文件权限为 600 (仅所有者可读写)
+    if (process.platform !== 'win32') {
+      fs.chmodSync(getEnvPath(), 0o600);
+    }
+  } catch (err) {
+    throw new Error('Failed to write .env: ' + err.message);
+  }
+}
+
+// 读取 settings.json
+function readSettings() {
+  try {
+    if (!settingsExists()) {
+      return {};
+    }
+    const content = fs.readFileSync(getSettingsPath(), 'utf8');
+    return JSON.parse(content);
+  } catch (err) {
+    throw new Error('Failed to read settings.json: ' + err.message);
+  }
+}
+
+// 写入 settings.json
+function writeSettings(settings) {
+  try {
+    const content = JSON.stringify(settings, null, 2);
+    fs.writeFileSync(getSettingsPath(), content, 'utf8');
+  } catch (err) {
+    throw new Error('Failed to write settings.json: ' + err.message);
+  }
+}
+
+// 备份当前配置
+function backupSettings() {
+  try {
+    if (!configExists()) {
+      throw new Error('.env not found');
+    }
+
+    // 如果已经有备份，不覆盖
+    if (hasBackup()) {
+      console.log('Backup already exists, skipping backup');
+      return { success: true, alreadyExists: true };
+    }
+
+    // 备份 .env
+    const envContent = fs.readFileSync(getEnvPath(), 'utf8');
+    fs.writeFileSync(getEnvBackupPath(), envContent, 'utf8');
+
+    // 设置备份文件权限为 600
+    if (process.platform !== 'win32') {
+      fs.chmodSync(getEnvBackupPath(), 0o600);
+    }
+
+    // 备份 settings.json (如果存在)
+    if (settingsExists()) {
+      const settingsContent = fs.readFileSync(getSettingsPath(), 'utf8');
+      fs.writeFileSync(getSettingsBackupPath(), settingsContent, 'utf8');
+    }
+
+    console.log('Gemini settings backed up');
+    return { success: true, alreadyExists: false };
+  } catch (err) {
+    throw new Error('Failed to backup settings: ' + err.message);
+  }
+}
+
+// 恢复配置
+function restoreSettings() {
+  try {
+    if (!hasBackup()) {
+      throw new Error('No backup found');
+    }
+
+    // 恢复 .env
+    if (fs.existsSync(getEnvBackupPath())) {
+      const content = fs.readFileSync(getEnvBackupPath(), 'utf8');
+      fs.writeFileSync(getEnvPath(), content, 'utf8');
+      fs.unlinkSync(getEnvBackupPath());
+
+      // 设置文件权限为 600
+      if (process.platform !== 'win32') {
+        fs.chmodSync(getEnvPath(), 0o600);
+      }
+    }
+
+    // 恢复 settings.json
+    if (fs.existsSync(getSettingsBackupPath())) {
+      const content = fs.readFileSync(getSettingsBackupPath(), 'utf8');
+      fs.writeFileSync(getSettingsPath(), content, 'utf8');
+      fs.unlinkSync(getSettingsBackupPath());
+    }
+
+    console.log('Gemini settings restored from backup');
+    return { success: true };
+  } catch (err) {
+    throw new Error('Failed to restore settings: ' + err.message);
+  }
+}
+
+// 设置代理配置
+function setProxyConfig(proxyPort) {
+  try {
+    // 先备份
+    backupSettings();
+
+    // 读取当前配置
+    const env = configExists() ? readEnv() : {};
+
+    // 设置代理 URL
+    env.GOOGLE_GEMINI_BASE_URL = `http://127.0.0.1:${proxyPort}`;
+    env.GEMINI_API_KEY = 'PROXY_KEY';
+    // 保留或设置默认模型
+    if (!env.GEMINI_MODEL) {
+      env.GEMINI_MODEL = 'gemini-2.5-pro';
+    }
+
+    // 写入 .env
+    writeEnv(env);
+
+    // 确保 settings.json 存在并配置正确的认证模式
+    const settings = settingsExists() ? readSettings() : {};
+    settings.security = settings.security || {};
+    settings.security.auth = settings.security.auth || {};
+    settings.security.auth.selectedType = 'gemini-api-key';
+
+    writeSettings(settings);
+
+    console.log(`Gemini settings updated to use proxy on port ${proxyPort}`);
+    return { success: true, port: proxyPort };
+  } catch (err) {
+    throw new Error('Failed to set proxy config: ' + err.message);
+  }
+}
+
+// 检查当前是否是代理配置
+function isProxyConfig() {
+  try {
+    if (!configExists()) {
+      return false;
+    }
+
+    const env = readEnv();
+
+    // 检查 GOOGLE_GEMINI_BASE_URL 是否指向本地代理
+    const baseUrl = env.GOOGLE_GEMINI_BASE_URL || '';
+    if (baseUrl.includes('127.0.0.1') || baseUrl.includes('localhost')) {
+      return true;
+    }
+
+    return false;
+  } catch (err) {
+    return false;
+  }
+}
+
+// 获取当前代理端口（如果是代理配置）
+function getCurrentProxyPort() {
+  try {
+    if (!isProxyConfig()) {
+      return null;
+    }
+
+    const env = readEnv();
+    const baseUrl = env.GOOGLE_GEMINI_BASE_URL || '';
+    const match = baseUrl.match(/:(\d+)/);
+    return match ? parseInt(match[1]) : null;
+  } catch (err) {
+    return null;
+  }
+}
+
+module.exports = {
+  getEnvPath,
+  getSettingsPath,
+  getEnvBackupPath,
+  getSettingsBackupPath,
+  configExists,
+  settingsExists,
+  hasBackup,
+  readEnv,
+  writeEnv,
+  readSettings,
+  writeSettings,
+  backupSettings,
+  restoreSettings,
+  setProxyConfig,
+  isProxyConfig,
+  getCurrentProxyPort
+};

package/src/server/services/gemini-statistics-service.js

@@ -0,0 +1,157 @@
+const {
+  recordRequest: recordSharedRequest,
+  getStatistics: getSharedStatistics,
+  getDailyStatistics: getSharedDailyStatistics,
+  getTodayStatistics: getSharedTodayStatistics
+} = require('./statistics-service');
+
+const TOOL_TYPE = 'gemini';
+
+function toNumber(value) {
+  const num = Number(value);
+  return Number.isFinite(num) ? num : 0;
+}
+
+function normalizeToolTokens(tokens = {}) {
+  const input = toNumber(tokens.input);
+  const output = toNumber(tokens.output);
+  const cached = toNumber(tokens.cached);
+  const cacheCreation = toNumber(tokens.cacheCreation);
+  const cacheRead = toNumber(tokens.cacheRead || cached);
+  const total = toNumber(tokens.total) || (input + output);
+
+  return {
+    input,
+    output,
+    cached,
+    cacheCreation,
+    cacheRead,
+    total
+  };
+}
+
+function toLegacyEntryShape(entry = {}, includeName = false) {
+  const normalized = normalizeToolTokens(entry.tokens || {});
+  const result = {
+    requests: toNumber(entry.requests),
+    tokens: {
+      input: normalized.input,
+      output: normalized.output,
+      cached: normalized.cached,
+      total: normalized.total
+    },
+    cost: toNumber(entry.cost)
+  };
+
+  if (includeName) {
+    result.name = entry.name || '';
+    if (entry.firstUsed) result.firstUsed = entry.firstUsed;
+    if (entry.lastUsed) result.lastUsed = entry.lastUsed;
+  }
+
+  return result;
+}
+
+function pickToolScope(sharedStats = {}) {
+  const byToolType = sharedStats.byToolType || {};
+  const toolScope = byToolType[TOOL_TYPE] || {};
+
+  let byChannel = {};
+  let byModel = {};
+
+  if (toolScope.channels && typeof toolScope.channels === 'object') {
+    byChannel = toolScope.channels;
+  } else {
+    byChannel = Object.fromEntries(
+      Object.entries(sharedStats.byChannel || {}).filter(([, value]) => value?.toolType === TOOL_TYPE)
+    );
+  }
+
+  if (toolScope.models && typeof toolScope.models === 'object') {
+    byModel = toolScope.models;
+  } else {
+    byModel = Object.fromEntries(
+      Object.entries(sharedStats.byModel || {}).filter(([, value]) => value?.toolType === TOOL_TYPE)
+    );
+  }
+
+  return { toolScope, byChannel, byModel };
+}
+
+function buildSummaryStatistics(sharedStats = {}) {
+  const { toolScope, byChannel, byModel } = pickToolScope(sharedStats);
+  const normalized = toLegacyEntryShape(toolScope);
+
+  return {
+    version: '1.0',
+    lastUpdated: sharedStats.lastUpdated || new Date().toISOString(),
+    global: {
+      totalRequests: normalized.requests,
+      totalTokens: normalized.tokens.total,
+      totalCost: normalized.cost
+    },
+    byChannel: Object.fromEntries(
+      Object.entries(byChannel).map(([key, value]) => [key, toLegacyEntryShape(value, true)])
+    ),
+    byModel: Object.fromEntries(
+      Object.entries(byModel).map(([key, value]) => [key, toLegacyEntryShape(value)])
+    )
+  };
+}
+
+function buildDailyStatistics(sharedDaily = {}, fallbackDate) {
+  const { byToolType = {} } = sharedDaily;
+  const toolScope = byToolType[TOOL_TYPE] || {};
+  const normalized = toLegacyEntryShape(toolScope);
+  const byChannel = toolScope.channels || {};
+  const byModel = toolScope.models || {};
+
+  return {
+    date: sharedDaily.date || fallbackDate,
+    summary: {
+      requests: normalized.requests,
+      tokens: normalized.tokens.total,
+      cost: normalized.cost
+    },
+    byChannel: Object.fromEntries(
+      Object.entries(byChannel).map(([key, value]) => [key, toLegacyEntryShape(value, true)])
+    ),
+    byModel: Object.fromEntries(
+      Object.entries(byModel).map(([key, value]) => [key, toLegacyEntryShape(value)])
+    )
+  };
+}
+
+function recordRequest(requestData = {}) {
+  const normalizedTokens = normalizeToolTokens(requestData.tokens || {});
+  return recordSharedRequest({
+    ...requestData,
+    toolType: TOOL_TYPE,
+    tokens: {
+      input: normalizedTokens.input,
+      output: normalizedTokens.output,
+      cacheCreation: normalizedTokens.cacheCreation,
+      cacheRead: normalizedTokens.cacheRead,
+      total: normalizedTokens.total
+    }
+  });
+}
+
+function getStatistics() {
+  return buildSummaryStatistics(getSharedStatistics());
+}
+
+function getDailyStatistics(date) {
+  return buildDailyStatistics(getSharedDailyStatistics(date), date);
+}
+
+function getTodayStatistics() {
+  return buildDailyStatistics(getSharedTodayStatistics());
+}
+
+module.exports = {
+  recordRequest,
+  getStatistics,
+  getDailyStatistics,
+  getTodayStatistics
+};

package/src/server/services/health-check.js

@@ -0,0 +1,85 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 健康检查：确保项目的 .claude/sessions 目录存在
+ * @param {string} projectPath - 项目路径
+ * @returns {Object} 检查结果
+ */
+function ensureProjectClaudeDir(projectPath) {
+  try {
+    const claudeDir = path.join(projectPath, '.claude');
+    const sessionsDir = path.join(claudeDir, 'sessions');
+
+    const result = {
+      projectPath,
+      claudeDirExists: fs.existsSync(claudeDir),
+      sessionsDirExists: fs.existsSync(sessionsDir),
+      created: false,
+      error: null
+    };
+
+    // 如果目录不存在，自动创建
+    if (!result.sessionsDirExists) {
+      try {
+        fs.mkdirSync(sessionsDir, { recursive: true });
+        result.created = true;
+        result.sessionsDirExists = true;
+        result.claudeDirExists = true;
+        console.log(`[Health Check] Created .claude/sessions directory for: ${projectPath}`);
+      } catch (err) {
+        result.error = `Failed to create directory: ${err.message}`;
+        console.error(`[Health Check] Error creating directory for ${projectPath}:`, err);
+      }
+    }
+
+    return result;
+  } catch (err) {
+    return {
+      projectPath,
+      error: err.message
+    };
+  }
+}
+
+/**
+ * 批量检查所有项目的健康状态
+ * @param {Array} projects - 项目列表
+ * @returns {Object} 汇总结果
+ */
+function healthCheckAllProjects(projects) {
+  const results = [];
+  let checkedCount = 0;
+  let createdCount = 0;
+  let errorCount = 0;
+
+  for (const project of projects) {
+    if (!project.fullPath) continue;
+
+    const result = ensureProjectClaudeDir(project.fullPath);
+    results.push(result);
+    checkedCount++;
+
+    if (result.created) {
+      createdCount++;
+    }
+    if (result.error) {
+      errorCount++;
+    }
+  }
+
+  return {
+    summary: {
+      total: checkedCount,
+      created: createdCount,
+      errors: errorCount,
+      healthy: checkedCount - errorCount
+    },
+    results
+  };
+}
+
+module.exports = {
+  ensureProjectClaudeDir,
+  healthCheckAllProjects
+};