coding-tool-x 3.7.10 → 3.7.11

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

@@ -0,0 +1,138 @@
+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/omp-sessions.js

@@ -212,6 +212,42 @@ function parseSessionFile(filePath) {
   };
 }
 
+function parseSessionUsageEvents(filePath) {
+  const entries = readJsonLines(filePath);
+  const header = entries.find(entry => entry?.type === 'session') || {};
+  const sessionId = header.id || parseOmpSessionId(filePath);
+  let activeProvider = '';
+  let activeModel = '';
+  const events = [];
+
+  entries.forEach((entry, index) => {
+    if (entry?.type === 'model_change') {
+      activeProvider = entry.provider || activeProvider;
+      activeModel = entry.modelId || entry.model || activeModel;
+      return;
+    }
+    if (entry?.type !== 'message') return;
+
+    const message = entry.message || {};
+    const role = message.role || entry.role;
+    if (role !== 'assistant') return;
+
+    const eventId = entry.id || message.id || `assistant-${index}`;
+    events.push({
+      key: `${filePath}:${eventId}`,
+      id: `${sessionId}:${eventId}`,
+      sessionId,
+      filePath,
+      provider: entry.provider || message.provider || activeProvider || '',
+      model: entry.model || message.model || activeModel || '',
+      timestamp: entry.timestamp || message.timestamp || header.timestamp || null,
+      usage: parseUsage(entry.usage || message.usage || {})
+    });
+  });
+
+  return events;
+}
+
 function getOmpSessionPaths() {
   // Reading historical sessions normally only needs OMP's native directory
   // convention. Avoid starting the CLI here: project/count snapshot workers
@@ -264,6 +300,47 @@ function getAllSessions() {
     .sort((a, b) => (b.mtimeMs || 0) - (a.mtimeMs || 0));
 }
 
+function getOmpUsageEvents(rootDir = getOmpSessionPaths().sessions) {
+  return scanSessionFiles(rootDir).flatMap((filePath) => {
+    try {
+      return parseSessionUsageEvents(filePath);
+    } catch (error) {
+      console.warn('[OMP Sessions] Failed to parse usage events:', filePath, error.message);
+      return [];
+    }
+  });
+}
+
+function createOmpUsageEventCursor(rootDir = null) {
+  let signatures = new Map();
+
+  return {
+    read() {
+      const files = scanSessionFiles(rootDir || getOmpSessionPaths().sessions);
+      const nextSignatures = new Map();
+      const events = [];
+
+      files.forEach((filePath) => {
+        try {
+          const stat = fs.statSync(filePath);
+          const signature = `${stat.size}:${stat.mtimeMs}`;
+          nextSignatures.set(filePath, signature);
+          if (signatures.get(filePath) === signature) return;
+          events.push(...parseSessionUsageEvents(filePath));
+        } catch (error) {
+          console.warn('[OMP Sessions] Failed to read changed usage events:', filePath, error.message);
+        }
+      });
+
+      signatures = nextSignatures;
+      return events;
+    },
+    reset() {
+      signatures = new Map();
+    }
+  };
+}
+
 function loadProjectOrder() {
   const data = safeReadJson(PROJECT_ORDER_FILE, { order: [] });
   return Array.isArray(data.order) ? data.order : [];
@@ -491,12 +568,14 @@ function isOmpCliInstalled() {
 
 module.exports = {
   buildLaunchCommand,
+  createOmpUsageEventCursor,
   decodeProjectName,
   deleteProject,
   deleteSession,
   encodeProjectName,
   forkSession,
   getAllSessions,
+  getOmpUsageEvents,
   getProjectAndSessionCounts,
   getProjects,
   getRecentSessions,
@@ -506,6 +585,7 @@ module.exports = {
   isOmpInstalled: isOmpCliInstalled,
   normalizeSession,
   parseSessionFile,
+  parseSessionUsageEvents,
   scanSessionFiles,
   searchSessions,
   saveProjectOrder,