coding-tool-x 3.2.0

package/src/server/services/request-logger.js

@@ -0,0 +1,130 @@
+/**
+ * 请求日志服务
+ *
+ * 通过环境变量控制是否记录各类请求日志：
+ *
+ *   CC_TOOL_LOG_REQUESTS=true        - 总开关：是否将代理请求快照写入 JSONL 文件（默认 false，需显式开启）
+ *   CC_TOOL_LOG_API_REQUESTS=true    - 是否将 Web UI REST API 请求写入日志文件（默认 false）
+ *
+ * 日志文件位置：
+ *   ~/.cc-tool/claude-requests.jsonl
+ *   ~/.cc-tool/codex-requests.jsonl
+ *   ~/.cc-tool/gemini-requests.jsonl
+ *   ~/.cc-tool/opencode-requests.jsonl
+ *   ~/.cc-tool/logs/api-requests.jsonl
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CC_TOOL_DIR = path.join(os.homedir(), '.cc-tool');
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+/**
+ * 总开关：代理请求快照写文件
+ * 环境变量 CC_TOOL_LOG_REQUESTS=true 时开启，默认关闭（避免将含完整 messages 的请求体无限写入磁盘）
+ */
+function isProxyRequestLoggingEnabled() {
+  const val = process.env.CC_TOOL_LOG_REQUESTS;
+  if (!val) return false;
+  return val.toLowerCase() === 'true' || val === '1';
+}
+
+/**
+ * REST API 请求日志开关
+ * 环境变量 CC_TOOL_LOG_API_REQUESTS=true 时开启，默认关闭
+ */
+function isApiRequestLoggingEnabled() {
+  const val = process.env.CC_TOOL_LOG_API_REQUESTS;
+  if (!val) return false;
+  return val.toLowerCase() === 'true' || val === '1';
+}
+
+/**
+ * 将代理请求快照异步追加写入 JSONL 文件
+ * @param {string} source - 来源类型: 'claude' | 'codex' | 'gemini' | 'opencode'
+ * @param {object} payload - 要写入的数据对象
+ */
+function persistProxyRequestSnapshot(source, payload) {
+  if (!isProxyRequestLoggingEnabled()) return;
+
+  try {
+    ensureDir(CC_TOOL_DIR);
+    const logPath = path.join(CC_TOOL_DIR, `${source}-requests.jsonl`);
+    fs.appendFile(logPath, `${JSON.stringify(payload)}\n`, (error) => {
+      if (error) {
+        console.error(`[request-logger] Failed to persist ${source} request snapshot:`, error);
+      }
+    });
+  } catch (error) {
+    console.error(`[request-logger] Failed to persist ${source} request snapshot:`, error);
+  }
+}
+
+/**
+ * 创建 Express 中间件，用于记录 REST API 请求
+ * 仅当 CC_TOOL_LOG_API_REQUESTS=true 时生效
+ */
+function createApiRequestLogger() {
+  return function apiRequestLogger(req, res, next) {
+    if (!isApiRequestLoggingEnabled()) return next();
+
+    const startTime = Date.now();
+    const originalJson = res.json.bind(res);
+    const originalSend = res.send.bind(res);
+
+    let statusCode = 200;
+
+    // 拦截响应以获取状态码和耗时
+    function logAndCallThrough(fn, body) {
+      statusCode = res.statusCode || 200;
+      const duration = Date.now() - startTime;
+      const entry = {
+        timestamp: new Date().toISOString(),
+        method: req.method,
+        path: req.path,
+        url: req.originalUrl || req.url,
+        statusCode,
+        duration,
+        ip: req.ip || req.connection?.remoteAddress || null,
+        userAgent: req.headers?.['user-agent'] || null
+      };
+
+      try {
+        ensureDir(path.join(CC_TOOL_DIR, 'logs'));
+        const logPath = path.join(CC_TOOL_DIR, 'logs', 'api-requests.jsonl');
+        fs.appendFile(logPath, `${JSON.stringify(entry)}\n`, (err) => {
+          if (err) {
+            console.error('[request-logger] Failed to write API request log:', err);
+          }
+        });
+      } catch (err) {
+        console.error('[request-logger] Failed to write API request log:', err);
+      }
+
+      return fn(body);
+    }
+
+    res.json = (body) => logAndCallThrough(originalJson, body);
+    res.send = (body) => {
+      // 对于非 JSON 响应，只在实际调用 send 时记录一次
+      if (res.headersSent) return originalSend(body);
+      return logAndCallThrough(originalSend, body);
+    };
+
+    next();
+  };
+}
+
+module.exports = {
+  isProxyRequestLoggingEnabled,
+  isApiRequestLoggingEnabled,
+  persistProxyRequestSnapshot,
+  createApiRequestLogger
+};

package/src/server/services/response-decoder.js

@@ -0,0 +1,21 @@
+const zlib = require('zlib');
+
+function createDecodedStream(res) {
+  const encoding = String(res.headers['content-encoding'] || '').toLowerCase();
+
+  if (encoding.includes('gzip')) {
+    return res.pipe(zlib.createGunzip());
+  }
+  if (encoding.includes('deflate')) {
+    return res.pipe(zlib.createInflate());
+  }
+  if (encoding.includes('br') && typeof zlib.createBrotliDecompress === 'function') {
+    return res.pipe(zlib.createBrotliDecompress());
+  }
+
+  return res;
+}
+
+module.exports = {
+  createDecodedStream
+};

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

@@ -0,0 +1,131 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+const SECURITY_DIR = path.join(os.homedir(), '.cc-tool');
+const SECURITY_FILE = path.join(SECURITY_DIR, 'security.json');
+
+const DEFAULT_SECURITY_CONFIG = {
+  passwordHash: '',
+  salt: '',
+  updatedAt: null
+};
+
+const PBKDF2_ITERATIONS = 120000;
+const PBKDF2_KEYLEN = 64;
+const PBKDF2_DIGEST = 'sha512';
+
+function ensureSecurityDir() {
+  if (!fs.existsSync(SECURITY_DIR)) {
+    fs.mkdirSync(SECURITY_DIR, { recursive: true });
+  }
+}
+
+function readSecurityConfig() {
+  ensureSecurityDir();
+
+  if (!fs.existsSync(SECURITY_FILE)) {
+    return { ...DEFAULT_SECURITY_CONFIG };
+  }
+
+  try {
+    const content = fs.readFileSync(SECURITY_FILE, 'utf8');
+    const data = JSON.parse(content);
+    return {
+      ...DEFAULT_SECURITY_CONFIG,
+      ...data
+    };
+  } catch (error) {
+    console.error('Error loading security config:', error);
+    return { ...DEFAULT_SECURITY_CONFIG };
+  }
+}
+
+function writeSecurityConfig(config) {
+  ensureSecurityDir();
+  fs.writeFileSync(SECURITY_FILE, JSON.stringify(config, null, 2), 'utf8');
+  try {
+    fs.chmodSync(SECURITY_FILE, 0o600);
+  } catch (error) {
+    console.warn('Failed to set security config permissions:', error);
+  }
+}
+
+function hasPassword(config) {
+  return Boolean(config.passwordHash && config.salt);
+}
+
+function hashPassword(password, salt) {
+  return crypto
+    .pbkdf2Sync(password, salt, PBKDF2_ITERATIONS, PBKDF2_KEYLEN, PBKDF2_DIGEST)
+    .toString('hex');
+}
+
+function safeEqualHash(a, b) {
+  try {
+    const bufferA = Buffer.from(a, 'hex');
+    const bufferB = Buffer.from(b, 'hex');
+    if (bufferA.length !== bufferB.length) {
+      return false;
+    }
+    return crypto.timingSafeEqual(bufferA, bufferB);
+  } catch (error) {
+    return false;
+  }
+}
+
+function getSecurityStatus() {
+  const config = readSecurityConfig();
+  return { hasPassword: hasPassword(config) };
+}
+
+function verifySecurityPassword(password) {
+  const config = readSecurityConfig();
+  if (!hasPassword(config)) {
+    return { ok: false, reason: 'not_set' };
+  }
+  const hash = hashPassword(password, config.salt);
+  return { ok: safeEqualHash(hash, config.passwordHash) };
+}
+
+function setSecurityPassword({ currentPassword, newPassword }) {
+  if (typeof newPassword !== 'string' || newPassword.length < 4) {
+    const error = new Error('新密码至少 4 位');
+    error.code = 'WEAK_PASSWORD';
+    throw error;
+  }
+
+  const config = readSecurityConfig();
+  if (hasPassword(config)) {
+    if (typeof currentPassword !== 'string' || !currentPassword) {
+      const error = new Error('请输入当前密码');
+      error.code = 'CURRENT_REQUIRED';
+      throw error;
+    }
+    const verifyResult = verifySecurityPassword(currentPassword);
+    if (!verifyResult.ok) {
+      const error = new Error('当前密码错误');
+      error.code = 'INVALID_PASSWORD';
+      throw error;
+    }
+  }
+
+  const salt = crypto.randomBytes(16).toString('hex');
+  const passwordHash = hashPassword(newPassword, salt);
+  const nextConfig = {
+    ...config,
+    passwordHash,
+    salt,
+    updatedAt: new Date().toISOString()
+  };
+
+  writeSecurityConfig(nextConfig);
+  return { hasPassword: true };
+}
+
+module.exports = {
+  getSecurityStatus,
+  verifySecurityPassword,
+  setSecurityPassword
+};

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

@@ -0,0 +1,127 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const PROJECTS_CACHE_TTL = 30 * 1000; // 30s
+const projectsCache = new Map();
+
+const HAS_MESSAGES_CACHE_LIMIT = 50000;
+const hasMessagesCache = new Map();
+let hasMessagesPersisted = {};
+let hasMessagesPersistTimer = null;
+
+function getCcToolDir() {
+  return path.join(os.homedir(), '.cc-tool');
+}
+
+function ensureDirExists(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function getProjectsCacheKey(config) {
+  return config?.projectsDir || '__default__';
+}
+
+function getCachedProjects(config) {
+  const cacheEntry = projectsCache.get(getProjectsCacheKey(config));
+  if (!cacheEntry) return null;
+  if ((Date.now() - cacheEntry.timestamp) > PROJECTS_CACHE_TTL) {
+    projectsCache.delete(getProjectsCacheKey(config));
+    return null;
+  }
+  return cacheEntry.data;
+}
+
+function setCachedProjects(config, data) {
+  projectsCache.set(getProjectsCacheKey(config), {
+    data,
+    timestamp: Date.now()
+  });
+}
+
+function invalidateProjectsCache(configOrPath) {
+  if (!configOrPath) {
+    projectsCache.clear();
+    return;
+  }
+  const key = typeof configOrPath === 'string'
+    ? configOrPath
+    : getProjectsCacheKey(configOrPath);
+  projectsCache.delete(key);
+}
+
+const hasMessagesCacheFile = path.join(getCcToolDir(), 'session-has-cache.json');
+loadHasMessagesCacheFromDisk();
+
+function loadHasMessagesCacheFromDisk() {
+  try {
+    if (!fs.existsSync(hasMessagesCacheFile)) {
+      hasMessagesPersisted = {};
+      return;
+    }
+    const raw = fs.readFileSync(hasMessagesCacheFile, 'utf8');
+    const parsed = JSON.parse(raw) || {};
+    hasMessagesPersisted = parsed;
+    Object.entries(parsed).forEach(([filePath, entry]) => {
+      if (!entry || typeof entry !== 'object') return;
+      const { size, mtimeMs, value } = entry;
+      if (typeof size === 'number' && typeof mtimeMs === 'number' && typeof value === 'boolean') {
+        hasMessagesCache.set(`${filePath}:${size}:${mtimeMs}`, value);
+      }
+    });
+  } catch (err) {
+    hasMessagesPersisted = {};
+  }
+}
+
+function checkHasMessagesCache(filePath, stats) {
+  if (!filePath || !stats) return undefined;
+  const cacheKey = `${filePath}:${stats.size}:${stats.mtimeMs}`;
+  if (!hasMessagesCache.has(cacheKey)) {
+    return undefined;
+  }
+  return hasMessagesCache.get(cacheKey);
+}
+
+function rememberHasMessages(filePath, stats, value) {
+  if (!filePath || !stats) return;
+  const cacheKey = `${filePath}:${stats.size}:${stats.mtimeMs}`;
+  if (hasMessagesCache.size >= HAS_MESSAGES_CACHE_LIMIT) {
+    const firstKey = hasMessagesCache.keys().next().value;
+    if (firstKey) {
+      hasMessagesCache.delete(firstKey);
+    }
+  }
+  hasMessagesCache.set(cacheKey, value);
+
+  hasMessagesPersisted[filePath] = {
+    size: stats.size,
+    mtimeMs: stats.mtimeMs,
+    value
+  };
+  schedulePersistHasMessagesCache();
+}
+
+function schedulePersistHasMessagesCache() {
+  if (hasMessagesPersistTimer) return;
+  hasMessagesPersistTimer = setTimeout(() => {
+    try {
+      ensureDirExists(path.dirname(hasMessagesCacheFile));
+      fs.writeFileSync(hasMessagesCacheFile, JSON.stringify(hasMessagesPersisted, null, 2), 'utf8');
+    } catch (err) {
+      // ignore persistence errors
+    } finally {
+      hasMessagesPersistTimer = null;
+    }
+  }, 1000);
+}
+
+module.exports = {
+  getCachedProjects,
+  setCachedProjects,
+  invalidateProjectsCache,
+  checkHasMessagesCache,
+  rememberHasMessages
+};