coding-tool-x 3.8.3 → 3.8.5

package/src/server/services/omp-session-log-observer.js

@@ -1,138 +0,0 @@
-const { createOmpUsageEventCursor } = require('./omp-sessions');
-const { getEnabledChannels } = require('./omp-channels');
-const {
-  getManagedProviderId,
-  isManagedProviderId,
-  normalizeProviderId
-} = require('./omp-settings-manager');
-const { buildSuccessLogPayload, hasMeaningfulUsage } = require('./proxy-log-helper');
-const { broadcastLog } = require('../websocket-server');
-
-const DEFAULT_INTERVAL_MS = 5000;
-const DEFAULT_MAX_SEEN_EVENTS = 10000;
-let pollTimer = null;
-let seenEventKeys = new Set();
-let maxSeenEvents = DEFAULT_MAX_SEEN_EVENTS;
-let usageEventCursor = null;
-
-function getEventKey(event = {}) {
-  return String(event.key || event.id || '').trim();
-}
-
-function rememberEventKey(key) {
-  if (!key) return;
-  if (seenEventKeys.has(key)) {
-    seenEventKeys.delete(key);
-  }
-  seenEventKeys.add(key);
-  while (seenEventKeys.size > maxSeenEvents) {
-    seenEventKeys.delete(seenEventKeys.values().next().value);
-  }
-}
-
-function resolveChannel(event = {}, channels = getEnabledChannels()) {
-  const providerId = normalizeProviderId(event.provider || '');
-  const matched = (channels || []).find((channel) => {
-    const candidates = [
-      getManagedProviderId(channel),
-      channel.providerKey,
-      channel.provider,
-      channel.name,
-      channel.id
-    ].map(normalizeProviderId);
-    return candidates.includes(providerId);
-  });
-
-  return {
-    id: matched?.id || null,
-    name: matched?.name || event.provider || 'OMP'
-  };
-}
-
-function normalizeTimestamp(value) {
-  const timestamp = value ? new Date(value).getTime() : Date.now();
-  return Number.isFinite(timestamp) ? timestamp : Date.now();
-}
-
-function publishEvent(event, channels) {
-  if (isManagedProviderId(normalizeProviderId(event.provider || ''))) {
-    return false;
-  }
-  const channel = resolveChannel(event, channels);
-  const usage = event.usage || {};
-  broadcastLog(buildSuccessLogPayload({
-    source: 'omp',
-    requestId: event.id,
-    channel: channel.name,
-    model: event.model || '',
-    tokens: usage,
-    cost: Number(usage.cost) || 0,
-    timestamp: normalizeTimestamp(event.timestamp),
-    usageMissing: !hasMeaningfulUsage('omp', usage)
-  }));
-  return true;
-}
-
-function pollOmpSessionLogs() {
-  if (!pollTimer) return getOmpSessionLogObserverStatus();
-
-  const events = usageEventCursor.read();
-  const channels = getEnabledChannels();
-  events.forEach((event) => {
-    const key = getEventKey(event);
-    if (!key || seenEventKeys.has(key)) return;
-    rememberEventKey(key);
-    publishEvent(event, channels);
-  });
-  return getOmpSessionLogObserverStatus();
-}
-
-function startOmpSessionLogObserver(options = {}) {
-  if (pollTimer) return getOmpSessionLogObserverStatus();
-
-  usageEventCursor = createOmpUsageEventCursor();
-  maxSeenEvents = Math.max(1, Number(options.maxSeenEvents) || DEFAULT_MAX_SEEN_EVENTS);
-  seenEventKeys = new Set();
-  usageEventCursor.read().map(getEventKey).filter(Boolean).forEach(rememberEventKey);
-  const intervalMs = Math.max(100, Number(options.intervalMs) || DEFAULT_INTERVAL_MS);
-  pollTimer = setInterval(() => {
-    try {
-      pollOmpSessionLogs();
-    } catch (error) {
-      console.warn('[OMP Sessions] Failed to observe usage logs:', error.message);
-    }
-  }, intervalMs);
-  if (typeof pollTimer.unref === 'function') {
-    pollTimer.unref();
-  }
-  return getOmpSessionLogObserverStatus();
-}
-
-function stopOmpSessionLogObserver() {
-  if (pollTimer) {
-    clearInterval(pollTimer);
-  }
-  pollTimer = null;
-  seenEventKeys = new Set();
-  maxSeenEvents = DEFAULT_MAX_SEEN_EVENTS;
-  usageEventCursor?.reset?.();
-  usageEventCursor = null;
-  return getOmpSessionLogObserverStatus();
-}
-
-function getOmpSessionLogObserverStatus() {
-  return {
-    running: Boolean(pollTimer),
-    seenEvents: seenEventKeys.size
-  };
-}
-
-module.exports = {
-  startOmpSessionLogObserver,
-  stopOmpSessionLogObserver,
-  pollOmpSessionLogs,
-  getOmpSessionLogObserverStatus,
-  _test: {
-    resolveChannel
-  }
-};

package/src/server/services/opencode-gateway-adapters.js

@@ -1,43 +0,0 @@
-'use strict';
-
-const { createCodexRequest } = require('./codex-wire');
-const {
-  createClaudeRequest,
-  stripClaudeToolNamePrefix
-} = require('./claude-wire');
-const { createGeminiRequest } = require('./gemini-wire');
-
-function convertOpenCodePayloadToClaude(pathname, payload = {}, fallbackModel = '', options = {}) {
-  return createClaudeRequest(pathname, payload, {
-    fallbackModel,
-    sessionUserId: options.sessionUserId,
-    networkHeaders: false
-  }).body;
-}
-
-function convertOpenCodePayloadToCodexResponses(payload = {}, fallbackModel = '') {
-  const converted = createCodexRequest(payload, { fallbackModel });
-  return {
-    requestBody: converted.body,
-    model: converted.model
-  };
-}
-
-function convertOpenCodePayloadToGemini(pathname, payload = {}, fallbackModel = '') {
-  const converted = createGeminiRequest(pathname, payload, {
-    fallbackModel,
-    networkHeaders: false,
-    useCli: false
-  });
-  return {
-    model: converted.model,
-    requestBody: converted.body
-  };
-}
-
-module.exports = {
-  convertOpenCodePayloadToClaude,
-  convertOpenCodePayloadToCodexResponses,
-  convertOpenCodePayloadToGemini,
-  stripClaudeToolNamePrefix
-};

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

@@ -1,59 +0,0 @@
-'use strict';
-
-const {
-  getSnapshot,
-  invalidateSnapshot
-} = require('./snapshot-cache');
-
-const PROJECT_SNAPSHOT_TTL_MS = 60 * 1000;
-const PROJECT_SNAPSHOT_WAIT_ON_MISS_MS = process.env.NODE_ENV === 'test' ? 0 : 1500;
-const PROJECT_SNAPSHOT_WAIT_ON_FORCE_MS = process.env.NODE_ENV === 'test' ? 0 : 1500;
-
-function projectListKey(source) {
-  return `projects:list:${source}`;
-}
-
-function projectCountKey(source) {
-  return `dashboard:counts:${source}`;
-}
-
-function emptyProjectList(currentProject = null, extra = {}) {
-  return {
-    projects: [],
-    currentProject,
-    ...extra
-  };
-}
-
-async function getProjectListSnapshot(source, {
-  fallbackValue,
-  refresh,
-  force = false
-}) {
-  return getSnapshot(projectListKey(source), {
-    ttlMs: PROJECT_SNAPSHOT_TTL_MS,
-    fallbackValue,
-    refresh,
-    force,
-    backgroundOnMiss: !force,
-    staleWhileForce: true,
-    waitOnMissMs: PROJECT_SNAPSHOT_WAIT_ON_MISS_MS,
-    waitOnForceMs: PROJECT_SNAPSHOT_WAIT_ON_FORCE_MS
-  });
-}
-
-function invalidateProjectSnapshots(source) {
-  invalidateSnapshot(projectListKey(source));
-  invalidateSnapshot(projectCountKey(source));
-}
-
-module.exports = {
-  PROJECT_SNAPSHOT_TTL_MS,
-  PROJECT_SNAPSHOT_WAIT_ON_MISS_MS,
-  PROJECT_SNAPSHOT_WAIT_ON_FORCE_MS,
-  projectListKey,
-  projectCountKey,
-  emptyProjectList,
-  getProjectListSnapshot,
-  invalidateProjectSnapshots
-};

package/src/server/services/proxy-log-helper.js

@@ -1,298 +0,0 @@
-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 input = toNumber(tokens.input);
-  const output = toNumber(tokens.output);
-  const cacheCreation = toNumber(tokens.cacheCreation);
-  const cacheRead = toNumber(tokens.cacheRead);
-  const cached = toNumber(tokens.cached);
-  const reasoning = toNumber(tokens.reasoning);
-  let total = toNumber(tokens.total);
-
-  if (total <= 0) {
-    if (normalizedSource === 'claude') {
-      total = input + output + cacheCreation + cacheRead;
-    } else {
-      total = input + output;
-    }
-  }
-
-  return {
-    input,
-    output,
-    cacheCreation,
-    cacheRead,
-    cached,
-    reasoning,
-    total
-  };
-}
-
-function hasMeaningfulUsage(source, tokens = {}) {
-  const normalized = normalizeUsageTokens(source, tokens);
-  if (normalized.total > 0) return true;
-  if (normalized.input > 0 || normalized.output > 0) return true;
-  if (normalized.cacheCreation > 0 || normalized.cacheRead > 0) return true;
-  if (normalized.cached > 0 || normalized.reasoning > 0) return true;
-  return false;
-}
-
-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;
-}
-
-function buildFailureLogPayload({
-  source,
-  requestId,
-  channel,
-  model,
-  message,
-  error,
-  statusCode,
-  stage,
-  timestamp = Date.now()
-}) {
-  const rawErrorMessage = String(
-    error?.message
-    || error
-    || ''
-  ).trim();
-  const displayMessage = String(
-    message
-    || rawErrorMessage
-    || 'Request failed'
-  );
-
-  return {
-    type: 'log',
-    status: 'error',
-    id: requestId || `${normalizeToolSource(source)}-error-${timestamp}-${Math.random().toString(36).slice(2, 8)}`,
-    time: formatRealtimeTime(timestamp),
-    channel: channel || 'Unknown',
-    model: model || '',
-    message: displayMessage,
-    error: displayMessage,
-    rawError: rawErrorMessage || undefined,
-    statusCode: Number.isFinite(Number(statusCode)) ? Number(statusCode) : null,
-    stage: stage || 'proxy',
-    inputTokens: 0,
-    outputTokens: 0,
-    cacheCreation: 0,
-    cacheRead: 0,
-    cachedTokens: 0,
-    reasoningTokens: 0,
-    totalTokens: 0,
-    cost: 0,
-    source: normalizeToolSource(source),
-    timestamp
-  };
-}
-
-function publishUsageLog({
-  source,
-  metadata = {},
-  model,
-  tokens,
-  calculateCost,
-  broadcastLog,
-  recordRequest,
-  recordSuccess,
-  allowBroadcast = true
-}) {
-  const normalizedSource = normalizeToolSource(source);
-  const actualModel = resolveActualModel(model, metadata);
-  const normalizedTokens = normalizeUsageTokens(normalizedSource, tokens);
-  const usageAvailable = hasMeaningfulUsage(normalizedSource, normalizedTokens);
-  const requestId = metadata.id || `${normalizedSource}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const timestamp = Date.now();
-  const cost = typeof calculateCost === 'function'
-    ? calculateCost(actualModel || '', normalizedTokens)
-    : 0;
-
-  if (!usageAvailable && !actualModel) {
-    return null;
-  }
-
-  if (allowBroadcast && typeof broadcastLog === 'function') {
-    broadcastLog(buildSuccessLogPayload({
-      source: normalizedSource,
-      requestId,
-      channel: metadata.channel,
-      model: actualModel,
-      originalModel: metadata.originalModel,
-      redirectedModel: metadata.redirectedModel,
-      tokens: normalizedTokens,
-      cost,
-      timestamp,
-      usageMissing: !usageAvailable
-    }));
-  }
-
-  if (usageAvailable && typeof recordRequest === 'function') {
-    const entry = {
-      id: requestId,
-      timestamp: new Date(metadata.startTime || timestamp).toISOString(),
-      toolType: normalizedSource === 'claude' ? 'claude-code' : normalizedSource,
-      channel: metadata.channel,
-      channelId: metadata.channelId,
-      model: actualModel || '',
-      tokens: {
-        input: normalizedTokens.input,
-        output: normalizedTokens.output,
-        reasoning: normalizedTokens.reasoning,
-        cached: normalizedTokens.cached,
-        cacheCreation: normalizedTokens.cacheCreation,
-        cacheRead: normalizedTokens.cacheRead,
-        total: normalizedTokens.total
-      },
-      duration: Math.max(0, timestamp - toNumber(metadata.startTime || timestamp)),
-      success: true,
-      cost
-    };
-    if (metadata.originalModel) {
-      entry.originalModel = metadata.originalModel;
-    }
-    if (metadata.redirectedModel) {
-      entry.redirectedModel = metadata.redirectedModel;
-    }
-    recordRequest(entry);
-  }
-
-  if (typeof recordSuccess === 'function' && metadata.channelId) {
-    recordSuccess(metadata.channelId, normalizedSource);
-  }
-
-  return {
-    cost,
-    model: actualModel,
-    tokens: normalizedTokens,
-    timestamp,
-    usageMissing: !usageAvailable
-  };
-}
-
-function publishFailureLog({
-  source,
-  metadata = {},
-  channel,
-  model,
-  message,
-  error,
-  statusCode,
-  stage,
-  broadcastLog
-}) {
-  if (typeof broadcastLog !== 'function') {
-    return null;
-  }
-
-  const payload = buildFailureLogPayload({
-    source,
-    requestId: metadata.id,
-    channel: channel || metadata.channel,
-    model: model || metadata.model,
-    message,
-    error,
-    statusCode,
-    stage
-  });
-  broadcastLog(payload);
-  return payload;
-}
-
-module.exports = {
-  toNumber,
-  normalizeToolSource,
-  resolveActualModel,
-  normalizeUsageTokens,
-  hasMeaningfulUsage,
-  formatRealtimeTime,
-  buildSuccessLogPayload,
-  buildFailureLogPayload,
-  publishUsageLog,
-  publishFailureLog
-};

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

@@ -1,127 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { PATHS } = require('../../config/paths');
-
-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.dirname(PATHS.sessionHasCache);
-}
-
-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 = PATHS.sessionHasCache;
-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
-};