coding-tool-x 3.8.9 → 3.8.10

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

@@ -0,0 +1,71 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { parentPort, workerData } = require('worker_threads');
+const { DatabaseSync } = require('node:sqlite');
+
+const MIN_FREE_BYTES = 256 * 1024 * 1024;
+const MIN_FREE_RATIO = 0.2;
+
+function readPragmaNumber(db, name) {
+  return Number(db.prepare(`PRAGMA ${name}`).get()?.[name]) || 0;
+}
+
+function inspectDatabase(dbPath, db) {
+  db.exec('PRAGMA busy_timeout = 5000; PRAGMA cache_size = -16384;');
+  const pageSize = readPragmaNumber(db, 'page_size');
+  const pageCount = readPragmaNumber(db, 'page_count');
+  const freePageCount = readPragmaNumber(db, 'freelist_count');
+  const fileBytes = fs.statSync(dbPath).size;
+  const freeBytes = pageSize * freePageCount;
+  const pageBytes = pageSize * pageCount;
+
+  if (freeBytes < MIN_FREE_BYTES || freeBytes < pageBytes * MIN_FREE_RATIO) {
+    return { status: 'below-threshold', beforeBytes: fileBytes, freeBytes };
+  }
+
+  const disk = fs.statfsSync(path.dirname(dbPath));
+  const availableBytes = Number(disk.bavail) * Number(disk.bsize);
+  if (!Number.isFinite(availableBytes) || availableBytes < fileBytes) {
+    return { status: 'insufficient-space', beforeBytes: fileBytes, freeBytes };
+  }
+
+  const checkpoint = db.prepare('PRAGMA wal_checkpoint(TRUNCATE)').get();
+  if (Number(checkpoint?.busy) > 0) {
+    return { status: 'database-busy', beforeBytes: fileBytes, freeBytes };
+  }
+
+  return { status: 'ready', beforeBytes: fileBytes, freeBytes };
+}
+
+function compactDatabase(dbPath) {
+  if (!dbPath || !fs.existsSync(dbPath)) return { status: 'missing' };
+  const db = new DatabaseSync(dbPath, { timeout: 5000 });
+  try {
+    const inspection = inspectDatabase(dbPath, db);
+    if (inspection.status !== 'ready') return inspection;
+
+    db.exec('VACUUM;');
+    const checkpoint = db.prepare('PRAGMA wal_checkpoint(TRUNCATE)').get();
+    const afterBytes = fs.statSync(dbPath).size;
+    return {
+      status: 'compacted',
+      beforeBytes: inspection.beforeBytes,
+      afterBytes,
+      reclaimedBytes: Math.max(0, inspection.beforeBytes - afterBytes),
+      checkpointBusy: Number(checkpoint?.busy) > 0
+    };
+  } finally {
+    db.close();
+  }
+}
+
+try {
+  const result = compactDatabase(workerData?.dbPath);
+  parentPort.postMessage({ type: 'done', result });
+  parentPort.close();
+} catch (error) {
+  parentPort.postMessage({ type: 'error', error: error?.message || String(error) });
+  parentPort.close();
+}

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

@@ -0,0 +1,166 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { Worker } = require('worker_threads');
+const { PATHS } = require('../../config/paths');
+
+const MAINTENANCE_LOCK_STALE_MS = 30 * 60 * 1000;
+const INITIAL_MAINTENANCE_DELAY_MS = 60 * 1000;
+const RETRY_MAINTENANCE_DELAY_MS = 5 * 60 * 1000;
+const MAINTENANCE_WORKER_PATH = path.join(__dirname, 'session-history-maintenance-worker.js');
+
+const scheduledMaintenances = new Map();
+
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === 'EPERM';
+  }
+}
+
+function acquireMaintenanceLock(dbPath) {
+  const lockPath = `${path.resolve(dbPath)}.maintenance.lock`;
+
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    let fd;
+    try {
+      fd = fs.openSync(lockPath, 'wx', 0o600);
+      fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, startedAt: Date.now() }), 'utf8');
+      return { fd, lockPath };
+    } catch (error) {
+      if (fd !== undefined) {
+        try { fs.closeSync(fd); } catch (_) {}
+        try { fs.unlinkSync(lockPath); } catch (_) {}
+      }
+      if (error?.code !== 'EEXIST') throw error;
+    }
+
+    let owner = null;
+    let ageMs = 0;
+    try {
+      owner = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+      ageMs = Math.max(0, Date.now() - fs.statSync(lockPath).mtimeMs);
+    } catch (error) {
+      if (error?.code === 'ENOENT') continue;
+    }
+
+    const ownerPid = Number(owner?.pid);
+    if (isProcessAlive(ownerPid)) return null;
+    if ((!Number.isInteger(ownerPid) || ownerPid <= 0) && ageMs < MAINTENANCE_LOCK_STALE_MS) {
+      return null;
+    }
+
+    try {
+      fs.unlinkSync(lockPath);
+    } catch (error) {
+      if (error?.code !== 'ENOENT') return null;
+    }
+  }
+
+  return null;
+}
+
+function releaseMaintenanceLock(lock) {
+  if (!lock) return;
+  try { fs.closeSync(lock.fd); } catch (_) {}
+  try { fs.unlinkSync(lock.lockPath); } catch (_) {}
+}
+
+function runMaintenanceWorker(dbPath) {
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(MAINTENANCE_WORKER_PATH, { workerData: { dbPath } });
+    let settled = false;
+    worker.unref();
+
+    const finish = (error, result) => {
+      if (settled) return;
+      settled = true;
+      if (error) reject(error);
+      else resolve(result);
+    };
+
+    worker.on('message', (message) => {
+      if (message?.type === 'done') {
+        finish(null, message.result);
+      } else if (message?.type === 'error') {
+        finish(new Error(message.error || '会话索引维护线程失败'));
+      }
+    });
+
+    worker.once('error', (error) => finish(error));
+    worker.once('exit', (code) => {
+      if (!settled && code !== 0) {
+        finish(new Error(`会话索引维护线程异常退出（代码 ${code}）`));
+      } else if (!settled) {
+        finish(null, { status: 'skipped' });
+      }
+    });
+  });
+}
+
+function isRetryableMaintenanceError(error) {
+  return /SQLITE_BUSY|database is locked|database table is locked/i.test(error?.message || '');
+}
+
+async function runScheduledMaintenance(dbPath) {
+  let lock = null;
+  try {
+    if (!dbPath || !fs.existsSync(dbPath)) return false;
+
+    lock = acquireMaintenanceLock(dbPath);
+    if (!lock) return true;
+
+    const lockState = require('./session-history-index').cleanupStaleInventoryLocks(dbPath);
+    if (lockState.retained.length > 0) return true;
+
+    const result = await runMaintenanceWorker(dbPath);
+    return result.status === 'database-busy';
+  } catch (error) {
+    return isRetryableMaintenanceError(error);
+  } finally {
+    releaseMaintenanceLock(lock);
+  }
+}
+
+function scheduleMaintenanceAttempt(dbPath, delayMs) {
+  const key = path.resolve(dbPath);
+  const state = scheduledMaintenances.get(key);
+  if (!state || state.timer || state.running) return;
+
+  state.timer = setTimeout(async () => {
+    state.timer = null;
+    state.running = true;
+    let retry = false;
+    try {
+      retry = await runScheduledMaintenance(key);
+    } catch (_) {
+      retry = false;
+    } finally {
+      state.running = false;
+      if (retry) {
+        scheduleMaintenanceAttempt(key, RETRY_MAINTENANCE_DELAY_MS);
+      } else if (scheduledMaintenances.get(key) === state) {
+        scheduledMaintenances.delete(key);
+      }
+    }
+  }, delayMs);
+  state.timer.unref();
+}
+
+function scheduleSessionHistoryMaintenance(dbPath = PATHS.sessionHistoryIndex) {
+  if (process.env.NODE_ENV === 'test' || !dbPath) return false;
+
+  const key = path.resolve(dbPath);
+  if (scheduledMaintenances.has(key)) return false;
+
+  const state = { timer: null, running: false };
+  scheduledMaintenances.set(key, state);
+  scheduleMaintenanceAttempt(key, INITIAL_MAINTENANCE_DELAY_MS);
+  return true;
+}
+
+module.exports = { scheduleSessionHistoryMaintenance };

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

@@ -45,11 +45,14 @@ const { EffectiveControlService } = require('./effective-control-service');
 const { SkillArtifactStore } = require('./skill-artifact-store');
 const { SkillFormatAdapter } = require('./skill-format-adapters');
 const { SkillProjectionService } = require('./skill-projection-service');
+const { readTextFileLimited, truncateUtf8 } = require('./bounded-content');
 
 const SUPPORTED_REPO_PROVIDERS = ['github', 'gitlab', 'local'];
 const DEFAULT_GITHUB_HOST = 'https://github.com';
 const DEFAULT_GITLAB_HOST = 'https://gitlab.com';
 const CACHE_TTL = 5 * 60 * 1000;
+const MAX_SKILL_DETAIL_BYTES = 128 * 1024;
+const MAX_PREPARED_SKILL_CACHE_ENTRIES = 32;
 
 function sanitizeRefreshError(value) {
   return String(value || '')
@@ -392,7 +395,16 @@ class SkillService {
       invocation: skill.invocation || null,
       ...(skill.whenToUse ? { whenToUse: skill.whenToUse } : {}),
       ...(skill.metadata ? { metadata: skill.metadata } : {}),
-      ...(includeContent && skill.content !== undefined ? { content: skill.content } : {})
+      ...(includeContent && skill.content !== undefined
+        ? (() => {
+          const bounded = truncateUtf8(skill.content, MAX_SKILL_DETAIL_BYTES);
+          return {
+            content: bounded.text,
+            contentBytes: bounded.bytes,
+            contentTruncated: bounded.truncated
+          };
+        })()
+        : {})
     };
   }
 
@@ -534,7 +546,11 @@ class SkillService {
       return value.map(skill => ({ ...skill }));
     }
     const entry = { value, cachedAt: Date.now(), generation };
+    this._preparedSkillsCache.delete(cacheKey);
     this._preparedSkillsCache.set(cacheKey, entry);
+    while (this._preparedSkillsCache.size > MAX_PREPARED_SKILL_CACHE_ENTRIES) {
+      this._preparedSkillsCache.delete(this._preparedSkillsCache.keys().next().value);
+    }
     if (cacheKey === 'user:') {
       this.skillsCache = value;
       this.cacheTime = entry.cachedAt;
@@ -3663,7 +3679,8 @@ ${content}
       if (!fs.existsSync(skillFile) || fs.lstatSync(skillFile).isSymbolicLink()) {
         throw new Error('Skill detail contains an unavailable or symlinked SKILL.md');
       }
-      const content = fs.readFileSync(skillFile, 'utf8');
+      const boundedContent = readTextFileLimited(skillFile, MAX_SKILL_DETAIL_BYTES);
+      const content = boundedContent.text;
       const parsed = this.parseSkillMd(content);
       const bodyMatch = content.match(/^---\s*\n[\s\S]*?\n---\s*\n([\s\S]*)$/);
       const body = bodyMatch ? bodyMatch[1].trim() : content;
@@ -3676,6 +3693,8 @@ ${content}
         description: parsed.description || metadata.description || '',
         content: body,
         fullContent: content,
+        contentBytes: boundedContent.bytes,
+        contentTruncated: boundedContent.truncated,
         installed: enabled,
         enabled,
         cached: metadata.cached !== false,
@@ -3881,5 +3900,6 @@ ${content}
 module.exports = {
   SkillService,
   DEFAULT_REPOS: DEFAULT_REPOS_BY_PLATFORM.claude,
-  DEFAULT_REPOS_BY_PLATFORM
+  DEFAULT_REPOS_BY_PLATFORM,
+  MAX_SKILL_DETAIL_BYTES
 };

package/src/server/services/speed-test.js

@@ -38,47 +38,6 @@ function sanitizeTimeout(timeout) {
   return Math.min(Math.max(ms, MIN_TIMEOUT), MAX_TIMEOUT);
 }
 
-/**
- * 规范化批量测速并发度（默认小并发）
- */
-function sanitizeBatchConcurrency(concurrency, defaultValue = 2) {
-  const value = Number(concurrency);
-  if (!Number.isFinite(value) || value <= 0) {
-    return defaultValue;
-  }
-  return Math.min(Math.max(Math.round(value), 1), 5);
-}
-
-/**
- * 按并发限制执行异步任务，保持结果顺序与输入一致
- */
-async function runWithConcurrencyLimit(items, concurrency, taskFn) {
-  const list = Array.isArray(items) ? items : [];
-  if (list.length === 0) return [];
-
-  const limit = sanitizeBatchConcurrency(concurrency);
-  const results = new Array(list.length);
-  let cursor = 0;
-
-  async function worker() {
-    while (true) {
-      const currentIndex = cursor;
-      cursor += 1;
-      if (currentIndex >= list.length) {
-        return;
-      }
-      results[currentIndex] = await taskFn(list[currentIndex], currentIndex);
-    }
-  }
-
-  const workers = [];
-  const workerCount = Math.min(limit, list.length);
-  for (let i = 0; i < workerCount; i += 1) {
-    workers.push(worker());
-  }
-  await Promise.all(workers);
-  return results;
-}
 
 function normalizeNonEmptyString(value) {
   if (typeof value !== 'string') return null;
@@ -768,34 +727,6 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
   return primaryResult;
 }
 
-/**
- * 批量测试多个渠道
- * @param {Array} channels - 渠道列表
- * @param {number} timeout - 超时时间
- * @param {string} channelType - 渠道类型：'claude' | 'codex' | 'gemini'
- * @returns {Promise<Array>} 测试结果列表
- */
-async function testMultipleChannels(channels, timeout = DEFAULT_TIMEOUT, channelType = 'claude', concurrency = 2) {
-  const results = await runWithConcurrencyLimit(
-    channels,
-    concurrency,
-    channel => testChannelSpeed(channel, timeout, channelType)
-  );
-
-  // 按延迟排序（成功的在前，按延迟升序）
-  results.sort((a, b) => {
-    if (a.success && !b.success) return -1;
-    if (!a.success && b.success) return 1;
-    if (a.success && b.success) {
-      const aLatency = (a.latency === null || a.latency === undefined) ? Infinity : a.latency;
-      const bLatency = (b.latency === null || b.latency === undefined) ? Infinity : b.latency;
-      return aLatency - bLatency;
-    }
-    return 0;
-  });
-
-  return results;
-}
 
 /**
  * 获取缓存的测试结果
@@ -834,10 +765,7 @@ function getLatencyLevel(latency) {
 
 module.exports = {
   testChannelSpeed,
-  testMultipleChannels,
   getCachedResult,
   clearCache,
   getLatencyLevel,
-  sanitizeBatchConcurrency,
-  runWithConcurrencyLimit
 };

package/src/shared/channel-driver.js

@@ -202,6 +202,22 @@ function createChannelDriver({
       return failed(platform, capability, operation, error);
     }
   };
+  driver.speedTest = async (request = {}) => {
+    const operation = 'speedTest';
+    const channelId = request?.params?.channelId || request?.channelId;
+    const body = request?.body && typeof request.body === 'object' ? request.body : request;
+    if (!channelId) return invalid(platform, capability, operation, new Error('Channel id is required'));
+    try {
+      const channel = await findChannelById(channelId);
+      if (!channel) return invalid(platform, capability, operation, new Error(`Channel not found: ${channelId}`));
+      const { testChannelSpeed } = require('../server/services/speed-test');
+      const channelType = resolveModelListType(platform, channel, modelListType);
+      const data = await testChannelSpeed(channel, body?.timeout, channelType, { authSourceType: platform });
+      return ok(platform, capability, operation, data);
+    } catch (error) {
+      return failed(platform, capability, operation, error);
+    }
+  };
   driver.list = (...args) => call('list', listMethod, args, sanitizeChannels);
   driver.getEnabled = (...args) => call('getEnabled', 'getEnabledChannels', args, channels => sanitizeChannels(channels).channels);
   driver.create = (input, ...rest) => {

package/src/shared/driver-factories/api.js

@@ -71,6 +71,7 @@ function argsFor(capability, operation, context) {
     if (operation === 'update') return [params.channelId, context.body || {}];
     if (operation === 'remove') return [params.channelId];
     if (operation === 'models') return [params.channelId, options];
+    if (['speedTest', 'getAuth', 'syncLocalAuth', 'getAuthQuota'].includes(operation)) return [context];
     if (operation === 'applyToSettings') return [params.channelId];
     return [context.body || options];
   }