coding-tool-x 3.8.4 → 3.8.5

package/src/platforms/drivers/omp/native-config.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const path = require('path');
+const { createNativeSnapshotMethods } = require('../native-config-snapshot');
+const implementation = require('./channels-implementation');
+
+function createDriver({ requireImpl, ...context } = {}) {
+  const configuredPaths = context.pathContext?.native;
+  const currentNativePaths = context.pathContext?.customized && configuredPaths?.settings
+    ? configuredPaths
+    : require('../../../config/paths').NATIVE_PATHS.omp;
+  const managed = requireImpl
+    ? requireImpl('./omp/channels-implementation')
+    : implementation;
+  managed.configure?.({ pathContext: context.pathContext });
+  const ompDir = currentNativePaths.dir || path.dirname(currentNativePaths.settings);
+  const snapshotMethods = createNativeSnapshotMethods({
+    settings: { path: currentNativePaths.settings, format: 'yaml' },
+    auth: { path: currentNativePaths.auth, format: 'json', mode: 0o600 },
+    models: { path: currentNativePaths.models, format: 'yaml' },
+    commands: { path: currentNativePaths.commands || path.join(ompDir, 'commands'), format: 'directory' },
+    prompts: { path: currentNativePaths.prompts, format: 'directory' },
+    skills: { path: currentNativePaths.skills, format: 'directory' },
+    extensions: { path: currentNativePaths.extensions, format: 'directory' },
+    themes: { path: currentNativePaths.themes || path.join(ompDir, 'themes'), format: 'directory' },
+    packages: { path: currentNativePaths.packages || path.join(ompDir, 'packages'), format: 'directory' },
+    npmPackages: { path: path.join(ompDir, 'npm'), format: 'directory' },
+    gitPackages: { path: path.join(ompDir, 'git'), format: 'directory' }
+  }, { platform: 'omp', runtime: context.runtime });
+  return {
+    platform: 'omp',
+    capability: 'nativeConfig',
+    ...context,
+    ...snapshotMethods,
+    syncManagedProviders: (...args) => managed.syncManagedOmpProviders(...args),
+    disableManagedProviders: (...args) => managed.disableManagedOmpProviders(...args),
+    isManagedModeEnabled: (...args) => managed.isManagedOmpModeEnabled(...args),
+    clearNativeOAuth: () => {
+      const adapters = require('../../native-oauth-adapters');
+      adapters.configure?.(context);
+      return adapters.clearNativeOAuth('omp');
+    }
+  };
+}
+
+module.exports = { createDriver };

package/src/platforms/drivers/omp/native-logs.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const { createOmpUsageEventCursor, getOmpSessionPaths } = require('./sessions-implementation');
+const { getEnabledChannels } = require('./channels-implementation');
+const { getManagedProviderId, normalizeProviderId } = require('./native-config-implementation');
+const { normalizeCost, normalizeUsage } = require('../native-log-utils');
+const { calculateUsageCost } = require('../../../server/services/usage-log-utils');
+
+function resolveChannel(provider) {
+  const normalized = normalizeProviderId(provider || '');
+  const channel = getEnabledChannels().find(item => [
+    getManagedProviderId(item), item.providerKey, item.provider, item.name, item.id
+  ].map(normalizeProviderId).includes(normalized));
+  return channel ? { channelId: channel.id, channel: channel.name } : {};
+}
+
+function createDriver({ pathContext } = {}) {
+  if (pathContext?.customized) {
+    require('./sessions-implementation').configure?.({ pathContext });
+    require('./channels-implementation').configure?.({ pathContext });
+  }
+  return {
+    platform: 'omp',
+    capability: 'nativeLogs',
+    createNativeLogCursor({ skipInitialParse = false, onDiagnostic } = {}) {
+      const native = createOmpUsageEventCursor(getOmpSessionPaths().sessions, { skipInitialParse, onDiagnostic });
+      return {
+        initialize() { native.read(); },
+        readNewEvents() {
+          return native.read().map(event => ({
+            id: event.id,
+            source: 'omp',
+            sessionId: event.sessionId,
+            timestamp: event.timestamp,
+            provider: event.provider,
+            model: event.model,
+            tokens: normalizeUsage(event.usage),
+            cost: normalizeCost(event.usage?.cost)
+              || calculateUsageCost('omp', event.model || '', normalizeUsage(event.usage)),
+            ...resolveChannel(event.provider)
+          }));
+        },
+        read() { return this.readNewEvents(); },
+        reset() { native.reset(); },
+        close() { native.reset(); }
+      };
+    },
+    createCursor(options) { return this.createNativeLogCursor(options); }
+  };
+}
+
+module.exports = { createDriver };

package/src/{server/services/omp-native-plugin-adapter.js → platforms/drivers/omp/native-plugin-adapter.js}

@@ -1,7 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
-const { getOmpCommand, getOmpPaths } = require('./omp-config');
+const { getOmpCommand, getOmpPaths } = require('./config');
 
 const VALID_SCOPES = new Set(['user', 'project']);
 const GENERIC_SOURCE_KINDS = new Set(['npm', 'link', 'linked', 'marketplace']);
@@ -143,6 +143,62 @@ function normalizeMarketplacePlugin(entry, inheritedMarketplace = '') {
 class OmpNativePluginAdapter {
   constructor(options = {}) {
     this.commandRunner = options.commandRunner || execFileSync;
+    this.pathContext = options.pathContext || null;
+    this.cacheTtlMs = Math.max(0, Number(options.cacheTtlMs) || 1000);
+    this._operationCache = new Map();
+    this._operationInflight = new Map();
+  }
+
+  _operationKey(operation, options = {}) {
+    const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+    const scope = normalizeScope(options.scope, '');
+    return `${operation}:${cwd}:${scope}`;
+  }
+
+  _clone(value) {
+    if (value === undefined) return value;
+    try {
+      return JSON.parse(JSON.stringify(value));
+    } catch (_) {
+      return value;
+    }
+  }
+
+  _cachedOperation(operation, options, execute) {
+    const key = this._operationKey(operation, options);
+    const now = Date.now();
+    const cached = this._operationCache.get(key);
+    if (!options.force && cached && now - cached.cachedAt < this.cacheTtlMs) {
+      return this._clone(cached.value);
+    }
+    if (this._operationInflight.has(key)) {
+      return this._operationInflight.get(key);
+    }
+    try {
+      const value = execute();
+      this._operationCache.set(key, { value: this._clone(value), cachedAt: now });
+      return this._clone(value);
+    } catch (error) {
+      if (cached) {
+        return {
+          ...this._clone(cached.value),
+          error: {
+            message: error.message || String(error),
+            retryable: true
+          }
+        };
+      }
+      throw error;
+    }
+  }
+
+  invalidate(options = {}) {
+    const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+    const scope = normalizeScope(options.scope, '');
+    const suffix = `:${cwd}:${scope}`;
+    for (const key of this._operationCache.keys()) {
+      if (key.endsWith(suffix)) this._operationCache.delete(key);
+    }
   }
 
   run(args, options = {}) {
@@ -169,6 +225,14 @@ class OmpNativePluginAdapter {
   }
 
   listPlugins(options = {}) {
+    return this._cachedOperation(
+      'plugin:list',
+      options,
+      () => this._listPluginsUncached(options)
+    );
+  }
+
+  _listPluginsUncached(options = {}) {
     const payload = this.runJson(['plugin', 'list', '--json'], options);
     if (!payload || typeof payload !== 'object') {
       throw new Error('OMP plugin list returned an invalid JSON payload');
@@ -193,7 +257,10 @@ class OmpNativePluginAdapter {
   }
 
   listLooseExtensions() {
-    const extensionsDir = getOmpPaths().extensions;
+    const extensionsDir = this.pathContext?.customized
+      ? (this.pathContext.native?.extensions
+        || path.join(this.pathContext.native?.dir || this.pathContext.home || process.cwd(), 'extensions'))
+      : getOmpPaths().extensions;
     if (!fs.existsSync(extensionsDir)) return [];
     const plugins = [];
 
@@ -256,6 +323,7 @@ class OmpNativePluginAdapter {
     if (options.force) args.push('--force');
     if (options.scope) args.push('--scope', normalizeScope(options.scope));
     this.run(args, options);
+    this.invalidate(options);
     const parsed = splitMarketplaceId(pluginId);
     return {
       success: true,
@@ -295,6 +363,7 @@ class OmpNativePluginAdapter {
       if (options.scope) args.push('--scope', normalizeScope(options.scope));
       this.run(args, options);
     }
+    this.invalidate(options);
     return {
       success: true,
       message: `Configuration updated for plugin "${target}"`
@@ -310,9 +379,18 @@ class OmpNativePluginAdapter {
     const args = ['plugin', action, target];
     if (options.scope) args.push('--scope', normalizeScope(options.scope));
     this.run(args, options);
+    this.invalidate(options);
   }
 
   discover(options = {}) {
+    return this._cachedOperation(
+      'plugin:discover',
+      options,
+      () => this._discoverUncached(options)
+    );
+  }
+
+  _discoverUncached(options = {}) {
     const output = this.run(['plugin', 'discover', '--json'], options);
     const text = stripAnsi(output).trim();
     if (!text || text.includes('No plugins available')) return [];
@@ -381,6 +459,14 @@ class OmpNativePluginAdapter {
   }
 
   listMarketplaces(options = {}) {
+    return this._cachedOperation(
+      'marketplace:list',
+      options,
+      () => this._listMarketplacesUncached(options)
+    );
+  }
+
+  _listMarketplacesUncached(options = {}) {
     const output = this.run(['plugin', 'marketplace', 'list', '--json'], options);
     const text = stripAnsi(output).trim();
     if (!text || text.includes('No marketplaces configured')) return [];
@@ -429,20 +515,21 @@ class OmpNativePluginAdapter {
     const target = String(source || '').trim();
     if (!target) throw new Error('Missing marketplace source');
     this.run(['plugin', 'marketplace', 'add', target], options);
+    this.invalidate(options);
     return this.listMarketplaces(options);
   }
 
   removeMarketplace(name, options = {}) {
     const target = String(name || '').trim();
-    if (!target) throw new Error('Missing marketplace name');
     this.run(['plugin', 'marketplace', 'remove', target], options);
+    this.invalidate(options);
     return this.listMarketplaces(options);
   }
 
   updateMarketplaces(name = '', options = {}) {
     const args = ['plugin', 'marketplace', 'update'];
-    if (name) args.push(name);
     this.run(args, options);
+    this.invalidate(options);
     return this.listMarketplaces(options);
   }
 }

package/src/platforms/drivers/omp/project-config.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const mcpFormat = require('../../../shared/mcp-format');
+const {
+  createProjectAdapter,
+  createJsonMcpHandlers,
+  validateMcpId
+} = require('../../../shared/project-config');
+
+function createAdapter({ manifest, fsImpl } = {}) {
+  const relativePath = manifest?.projectResources?.mcp?.path;
+  const mcpHandlers = createJsonMcpHandlers({
+    relativePath,
+    format: manifest?.projectResources?.mcp?.format || 'omp-json',
+    toNative: mcpFormat.convertToOmpMcpFormat,
+    fromNative: mcpFormat.convertFromOmpMcpFormat,
+    validateId: id => {
+      try {
+        return validateMcpId(id);
+      } catch {
+        throw new Error(`OMP MCP server ID "${id}" is invalid`);
+      }
+    },
+    fsImpl
+  });
+  return createProjectAdapter({ manifest, fsImpl, mcpHandlers });
+}
+
+module.exports = { createAdapter };

package/src/platforms/drivers/omp/projects.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const { createProjectsDriver } = require('../../../shared/driver-factories/projects');
+
+function createDriver(context = {}) {
+  return createProjectsDriver({
+    ...context,
+    platform: 'omp',
+    servicePath: './omp/sessions-implementation',
+    localServicePath: '../../platforms/drivers/omp/sessions-implementation',
+    availabilityMethod: 'isOmpInstalled',
+    onSuccess: operation => {
+      if (['saveProjectOrder', 'createProject', 'deleteProject'].includes(operation)) {
+        context.sessionHistoryIndex?.invalidateSource('omp');
+      }
+    }
+  });
+}
+
+module.exports = { createDriver };

package/src/platforms/drivers/omp/prompts.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const { createPromptDriver } = require('../../../shared/driver-factories/prompts');
+
+function createDriver(context = {}) {
+  return createPromptDriver({ ...context, platform: 'omp' });
+}
+
+module.exports = { createDriver };

package/src/{server/omp-proxy-server.js → platforms/drivers/omp/proxy-implementation.js}

@@ -1,5 +1,5 @@
-const { loadConfig } = require('../config/loader');
-const { saveProxyStartTime, clearProxyStartTime, getProxyStartTime, getProxyRuntime } = require('./services/proxy-runtime');
+const { loadConfig } = require('../../../config/loader');
+const { saveProxyStartTime, clearProxyStartTime, getProxyStartTime, getProxyRuntime } = require('../../../server/services/proxy-runtime');
 const {
   syncManagedOmpProviders,
   disableManagedOmpProviders,
@@ -11,15 +11,10 @@ const {
   loadManagedOmpActiveChannelId,
   loadManagedOmpModeState,
   getOrCreateOmpGatewaySecret
-} = require('./services/omp-channels');
-const {
-  startOmpSessionLogObserver,
-  stopOmpSessionLogObserver,
-  getOmpSessionLogObserverStatus
-} = require('./services/omp-session-log-observer');
-const { createOmpGateway } = require('./services/omp-gateway');
-const { prepareManagedOmpChannels } = require('./services/omp-gateway-routing');
-const { probeOmpAuthGateways } = require('./services/omp-auth-gateway-client');
+} = require('./channels-implementation');
+const { createOmpGateway } = require('./gateway');
+const { prepareManagedOmpChannels } = require('./gateway-routing');
+const { probeOmpAuthGateways } = require('./auth-gateway-client');
 
 let currentPort = null;
 let lastSyncResult = null;
@@ -91,7 +86,6 @@ async function startOmpProxyServerUnlocked(options = {}) {
     currentPort = null;
     throw error;
   }
-  startOmpSessionLogObserver();
   saveProxyStartTime('omp', preserveStartTime);
   return {
     success: true,
@@ -125,7 +119,6 @@ async function stopOmpProxyServerUnlocked(options = {}) {
     || enabledChannels[0]
     || null;
   gateway.beginDraining();
-  stopOmpSessionLogObserver();
   try {
     if (!preserveManagedMode) {
       if (activeChannel) {
@@ -137,7 +130,6 @@ async function stopOmpProxyServerUnlocked(options = {}) {
       disableManagedOmpMode();
     }
   } catch (error) {
-    startOmpSessionLogObserver();
     gateway.cancelDraining();
     throw error;
   }
@@ -189,7 +181,6 @@ function getOmpProxyStatus() {
     modelsPath: lastSyncResult?.modelsPath || lastSyncResult?.path || null,
     backupPath: lastSyncResult?.backupPath || null,
     modelsValidation: validation,
-    sessionLogObserver: getOmpSessionLogObserverStatus(),
     warnings: lastSyncResult?.warnings || []
   };
 }

package/src/platforms/drivers/omp/proxy.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { createProxyDriver } = require('../../../shared/proxy-driver');
+
+function createDriver(context = {}) {
+  return createProxyDriver({
+    ...context,
+    platform: 'omp',
+    servicePath: './omp/proxy-implementation',
+    localServicePath: '../platforms/drivers/omp/proxy-implementation',
+    exports: { status: 'getOmpProxyStatus', start: 'startOmpProxyServer', stop: 'stopOmpProxyServer' },
+    cliMetadata: { managedProviderConfig: true, defaultPort: 20092 }
+  });
+}
+
+module.exports = { createDriver };

package/src/platforms/drivers/omp/resource-sync.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const { createResourceSyncDriver } = require('../../../shared/driver-factories/resource-sync');
+
+function createDriver(context = {}) {
+  return createResourceSyncDriver({ ...context, platform: 'omp' });
+}
+
+module.exports = { createDriver };

package/src/{server/services/session-history-adapters/omp.js → platforms/drivers/omp/session-history-adapter.js}

@@ -3,9 +3,21 @@
 const fs = require('fs');
 const path = require('path');
 const { HOME_DIR } = require('../../../config/paths');
-const { getOmpPaths } = require('../omp-config');
+const { getOmpPaths } = require('./config');
+const { normalizeUsage: normalizeNativeUsage } = require('../native-log-utils');
+
+let ompSessionPathsOverride = null;
+
+function configure({ pathContext } = {}) {
+  require('./config').configure?.({ pathContext });
+  const native = pathContext?.customized ? (pathContext.native || {}) : {};
+  ompSessionPathsOverride = native.sessions
+    ? { ...native, agentDir: native.dir || path.dirname(native.sessions) }
+    : null;
+}
 
 function getOmpSessionPaths() {
+  if (ompSessionPathsOverride?.sessions) return ompSessionPathsOverride;
   return getOmpPaths(process.env, { resolveRuntime: false });
 }
 
@@ -68,16 +80,20 @@ function extractMessageText(message = {}) {
 }
 
 function parseUsage(usage = {}) {
-  const input = Number(usage.input ?? usage.inputTokens ?? usage.input_tokens ?? usage.prompt_tokens ?? usage.promptTokens ?? 0) || 0;
-  const output = Number(usage.output ?? usage.outputTokens ?? usage.output_tokens ?? usage.completion_tokens ?? usage.completionTokens ?? 0) || 0;
-  const cacheRead = Number(usage.cacheRead ?? usage.cache_read ?? usage.cachedTokens ?? usage.cached_tokens ?? usage.cache_read_input_tokens ?? 0) || 0;
-  const cacheWrite = Number(usage.cacheWrite ?? usage.cache_write ?? usage.cacheCreation ?? usage.cache_creation ?? usage.cache_creation_input_tokens ?? 0) || 0;
-  const reasoning = Number(usage.reasoningTokens ?? usage.reasoning_tokens ?? 0) || 0;
-  const total = Number(usage.totalTokens ?? usage.total_tokens ?? (input + output + cacheRead + cacheWrite + reasoning)) || 0;
+  const normalized = normalizeNativeUsage(usage);
+  const input = normalized.input;
+  const output = normalized.output;
+  const cacheRead = normalized.cacheRead;
+  const cacheWrite = normalized.cacheCreation;
+  const reasoning = normalized.reasoning;
+  const total = normalized.total;
   const cost = typeof usage.cost === 'number'
     ? usage.cost
     : Number(usage.cost?.total ?? usage.cost?.usd ?? 0) || 0;
-  return { input, output, cached: cacheRead, cacheRead, cacheWrite, reasoning, total, cost };
+  return {
+    input, output, cached: normalized.cached, cacheRead, cacheWrite,
+    cacheCreation: normalized.cacheCreation, reasoning, total, cost
+  };
 }
 
 function readJsonLines(filePath) {
@@ -134,30 +150,34 @@ function convertOmpEntry(entry = {}, index = 0) {
  * Inventory all OMP session files.
  * @returns {Promise<Array>}
  */
-async function inventory() {
+async function inventory({ projectsDir } = {}) {
   const descriptors = [];
   let sessionsDir;
   try {
-    sessionsDir = getOmpSessionPaths().sessions;
+    sessionsDir = projectsDir || getOmpSessionPaths().sessions;
+  } catch (_) {
+    return descriptors;
+  }
+  try {
+    await fs.promises.stat(sessionsDir);
   } catch (_) {
     return descriptors;
   }
-  if (!fs.existsSync(sessionsDir)) return descriptors;
 
-  function walk(dir) {
+  async function walk(dir) {
     let entries;
     try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
+      entries = await fs.promises.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       const fullPath = path.join(dir, entry.name);
       if (entry.isDirectory()) {
-        walk(fullPath);
+        await walk(fullPath);
       } else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
         try {
-          const stat = fs.statSync(fullPath);
+          const stat = await fs.promises.stat(fullPath);
           descriptors.push({
             filePath: fullPath,
             size: stat.size,
@@ -170,7 +190,7 @@ async function inventory() {
     }
   }
 
-  walk(sessionsDir);
+  await walk(sessionsDir);
   return descriptors;
 }
 
@@ -181,7 +201,11 @@ async function parse(descriptor) {
   const { filePath, size, mtimeMs } = descriptor;
   const entries = readJsonLines(filePath);
   const header = entries.find(entry => entry?.type === 'session') || {};
-  const cwd = header.cwd || '';
+  const cwd = header.cwd
+    || header.project?.cwd
+    || entries.find(entry => typeof entry?.cwd === 'string')?.cwd
+    || entries.find(entry => typeof entry?.message?.cwd === 'string')?.message.cwd
+    || '';
   const sessionId = header.id || parseOmpSessionId(filePath) || descriptor.sessionId;
 
   const parsedMessages = entries.map((entry, idx) => convertOmpEntry(entry, idx)).filter(Boolean);
@@ -253,4 +277,4 @@ async function parse(descriptor) {
   return { session, messages };
 }
 
-module.exports = { inventory, parse, convertOmpEntry, parseUsage, encodeProjectName: encodeProjectName, getDisplayName, readJsonLines, extractMessageText, normalizeTextContent };
+module.exports = { configure, inventory, parse, convertOmpEntry, parseUsage, encodeProjectName: encodeProjectName, getDisplayName, readJsonLines, extractMessageText, normalizeTextContent };