coding-tool-x 3.7.10 → 3.7.12

package/src/server/services/omp-native-plugin-adapter.js

@@ -0,0 +1,456 @@
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const { getOmpCommand, getOmpPaths } = require('./omp-config');
+
+const VALID_SCOPES = new Set(['user', 'project']);
+const GENERIC_SOURCE_KINDS = new Set(['npm', 'link', 'linked', 'marketplace']);
+
+function normalizeScope(scope, fallback = 'user') {
+  return VALID_SCOPES.has(scope) ? scope : fallback;
+}
+
+function parseJsonOutput(output, commandLabel, emptyMessages = []) {
+  const text = stripAnsi(output).trim();
+  if (!text || emptyMessages.some(message => text.includes(message))) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`OMP returned invalid JSON for "${commandLabel}"`);
+  }
+}
+
+function stripAnsi(output) {
+  return String(output || '').replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, '');
+}
+
+function splitMarketplaceId(pluginId = '') {
+  const value = String(pluginId || '');
+  const index = value.lastIndexOf('@');
+  if (index <= 0) return { name: value, marketplace: '' };
+  return {
+    name: value.slice(0, index),
+    marketplace: value.slice(index + 1)
+  };
+}
+
+function collectEntries(value, inherited = {}, result = []) {
+  if (Array.isArray(value)) {
+    value.forEach(item => collectEntries(item, inherited, result));
+    return result;
+  }
+  if (!value || typeof value !== 'object') return result;
+
+  const looksLikePlugin = Boolean(
+    value.name || value.id || value.pluginId || value.package || value.installPath
+  );
+  if (looksLikePlugin) {
+    result.push({ ...inherited, ...value });
+    return result;
+  }
+
+  for (const [key, nested] of Object.entries(value)) {
+    const next = { ...inherited };
+    if (key === 'user' || key === 'project') next.scope = key;
+    if (key === 'npm') next.pluginKind = 'npm';
+    if (key === 'linked' || key === 'link') next.pluginKind = 'link';
+    if (key === 'marketplace') next.pluginKind = 'marketplace';
+    collectEntries(nested, next, result);
+  }
+  return result;
+}
+
+function normalizeInstalledPlugin(entry, kindHint = '') {
+  const firstEntry = Array.isArray(entry.entries) ? entry.entries[0] || {} : {};
+  const pluginKind = entry.pluginKind
+    || entry.kind
+    || entry.sourceKind
+    || (entry.marketplace ? 'marketplace' : kindHint)
+    || (entry.linked ? 'link' : 'npm');
+  const isMarketplace = pluginKind === 'marketplace';
+  const sourceIdentity = String(entry.source || '').trim();
+  const rawIdentity = String(
+    entry.pluginId
+    || entry.id
+    || entry.package
+    || entry.installTarget
+    || (!GENERIC_SOURCE_KINDS.has(sourceIdentity.toLowerCase()) ? sourceIdentity : '')
+    || entry.name
+    || ''
+  ).trim();
+  const marketplace = String(entry.marketplace || '').trim();
+  const pluginId = isMarketplace && marketplace && !rawIdentity.endsWith(`@${marketplace}`)
+    ? `${rawIdentity}@${marketplace}`
+    : rawIdentity;
+  const parsed = isMarketplace ? splitMarketplaceId(pluginId) : { name: entry.name || pluginId, marketplace };
+  const scope = normalizeScope(entry.scope, 'user');
+
+  if (!pluginId) {
+    throw new Error('OMP plugin list returned an entry without a native identity');
+  }
+
+  return {
+    ...entry,
+    key: `omp:${pluginKind}:${pluginId}:${scope}`,
+    pluginId,
+    id: pluginId,
+    name: String(entry.displayName || entry.name || parsed.name || pluginId),
+    marketplace: marketplace || parsed.marketplace,
+    installTarget: pluginId,
+    directory: entry.directory || entry.installPath || pluginId,
+    installPath: entry.installPath || entry.path || firstEntry.installPath || firstEntry.path || '',
+    installSource: entry.installSource || entry.source || pluginId,
+    source: `omp-${pluginKind}`,
+    scope,
+    pluginKind,
+    pluginType: pluginKind,
+    version: entry.version || firstEntry.version || 'latest',
+    description: entry.description || entry.manifest?.description || firstEntry.description || '',
+    installed: true,
+    enabled: entry.enabled !== false && firstEntry.enabled !== false,
+    readonly: false
+  };
+}
+
+function normalizeMarketplacePlugin(entry, inheritedMarketplace = '') {
+  const marketplace = String(entry.marketplace || inheritedMarketplace || '').trim();
+  const rawName = String(entry.name || entry.id || entry.pluginId || '').trim();
+  if (!rawName) return null;
+  const parsed = splitMarketplaceId(rawName);
+  const name = parsed.name;
+  const marketplaceName = marketplace || parsed.marketplace;
+  const pluginId = marketplaceName ? `${name}@${marketplaceName}` : rawName;
+  return {
+    ...entry,
+    key: `omp-market:${pluginId}`,
+    pluginId,
+    id: pluginId,
+    name,
+    marketplace: marketplaceName,
+    installTarget: pluginId,
+    installSource: pluginId,
+    source: entry.source || pluginId,
+    directory: entry.directory || name,
+    version: entry.version || 'latest',
+    description: entry.description || '',
+    pluginKind: 'marketplace',
+    pluginType: 'marketplace',
+    readonly: false,
+    isInstalled: entry.installed === true
+  };
+}
+
+class OmpNativePluginAdapter {
+  constructor(options = {}) {
+    this.commandRunner = options.commandRunner || execFileSync;
+  }
+
+  run(args, options = {}) {
+    const command = getOmpCommand();
+    try {
+      return this.commandRunner(command, args, {
+        cwd: options.cwd || process.cwd(),
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: options.timeout || 120000,
+        windowsHide: true
+      });
+    } catch (error) {
+      const detail = String(error?.stderr || error?.message || error).trim();
+      throw new Error(
+        `OMP 17.1+ plugin CLI command failed (${command} ${args.join(' ')}): ${detail}`
+      );
+    }
+  }
+
+  runJson(args, options = {}, emptyMessages = []) {
+    const output = this.run(args, options);
+    return parseJsonOutput(output, args.join(' '), emptyMessages);
+  }
+
+  listPlugins(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');
+    }
+
+    const plugins = [];
+    for (const entry of collectEntries(payload.npm || [])) {
+      plugins.push(normalizeInstalledPlugin(entry, 'npm'));
+    }
+    for (const entry of collectEntries(payload.linked || payload.link || [])) {
+      plugins.push(normalizeInstalledPlugin(entry, 'link'));
+    }
+    for (const entry of collectEntries(payload.marketplace || [])) {
+      plugins.push(normalizeInstalledPlugin(entry, 'marketplace'));
+    }
+    plugins.push(...this.listLooseExtensions());
+    return {
+      plugins: options.cwd
+        ? plugins
+        : plugins.filter(plugin => plugin.scope !== 'project')
+    };
+  }
+
+  listLooseExtensions() {
+    const extensionsDir = getOmpPaths().extensions;
+    if (!fs.existsSync(extensionsDir)) return [];
+    const plugins = [];
+
+    for (const entry of fs.readdirSync(extensionsDir, { withFileTypes: true })) {
+      if (entry.name.startsWith('.')) continue;
+      const extension = path.extname(entry.name).toLowerCase();
+      if (!entry.isDirectory() && !['.js', '.mjs', '.cjs', '.ts'].includes(extension)) {
+        continue;
+      }
+      const installPath = path.join(extensionsDir, entry.name);
+      let manifest = {};
+      if (entry.isDirectory()) {
+        for (const manifestName of ['omp.json', 'extension.json', 'plugin.json', 'package.json']) {
+          const manifestPath = path.join(installPath, manifestName);
+          if (!fs.existsSync(manifestPath)) continue;
+          try {
+            manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+          } catch {
+            manifest = {};
+          }
+          break;
+        }
+      }
+      let realPath = installPath;
+      try {
+        realPath = fs.realpathSync(installPath);
+      } catch {
+        // The absolute install path remains a stable local identity.
+      }
+      const name = manifest.name || (entry.isDirectory()
+        ? entry.name
+        : entry.name.slice(0, -extension.length));
+      plugins.push({
+        key: `omp:extension:${realPath}`,
+        pluginId: `extension:${realPath}`,
+        id: `extension:${realPath}`,
+        name,
+        directory: entry.name,
+        installPath,
+        installTarget: '',
+        installSource: installPath,
+        source: 'omp-extension',
+        scope: 'user',
+        version: manifest.version || 'local',
+        description: manifest.description || '',
+        installed: true,
+        enabled: true,
+        pluginType: 'extension',
+        pluginKind: 'extension',
+        readonly: true
+      });
+    }
+    return plugins;
+  }
+
+  installPlugin(target, metadata = {}, options = {}) {
+    const pluginId = String(target || metadata.pluginId || metadata.installSource || '').trim();
+    if (!pluginId) throw new Error('Missing OMP plugin target');
+    const args = ['plugin', 'install', pluginId];
+    if (options.force) args.push('--force');
+    if (options.scope) args.push('--scope', normalizeScope(options.scope));
+    this.run(args, options);
+    const parsed = splitMarketplaceId(pluginId);
+    return {
+      success: true,
+      plugin: normalizeInstalledPlugin({
+        ...metadata,
+        pluginId,
+        name: metadata.name || parsed.name || pluginId,
+        marketplace: metadata.marketplace || parsed.marketplace,
+        scope: options.scope || metadata.scope,
+        pluginKind: metadata.pluginKind || (parsed.marketplace ? 'marketplace' : 'npm')
+      })
+    };
+  }
+
+  uninstallPlugin(pluginId, options = {}) {
+    this.runMutation('uninstall', pluginId, options);
+    return { success: true, message: 'Plugin uninstalled successfully' };
+  }
+
+  togglePlugin(pluginId, enabled, options = {}) {
+    this.runMutation(enabled ? 'enable' : 'disable', pluginId, options);
+    return {
+      pluginId,
+      name: splitMarketplaceId(pluginId).name,
+      scope: options.scope || 'user',
+      enabled,
+      success: true
+    };
+  }
+
+  updatePluginConfig(pluginId, config, options = {}) {
+    const target = String(pluginId || '').trim();
+    if (!target) throw new Error('Missing OMP pluginId');
+    for (const [key, value] of Object.entries(config || {})) {
+      const serialized = typeof value === 'string' ? value : JSON.stringify(value);
+      const args = ['plugin', 'config', 'set', target, key, serialized];
+      if (options.scope) args.push('--scope', normalizeScope(options.scope));
+      this.run(args, options);
+    }
+    return {
+      success: true,
+      message: `Configuration updated for plugin "${target}"`
+    };
+  }
+
+  runMutation(action, pluginId, options = {}) {
+    const target = String(pluginId || '').trim();
+    if (!target) throw new Error('Missing OMP pluginId');
+    if (target.startsWith('extension:')) {
+      throw new Error('OMP loose extensions are readonly and cannot be managed by the plugin CLI');
+    }
+    const args = ['plugin', action, target];
+    if (options.scope) args.push('--scope', normalizeScope(options.scope));
+    this.run(args, options);
+  }
+
+  discover(options = {}) {
+    const output = this.run(['plugin', 'discover', '--json'], options);
+    const text = stripAnsi(output).trim();
+    if (!text || text.includes('No plugins available')) return [];
+    let payload;
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      return this.discoverFromText(text, options);
+    }
+
+    const entries = [];
+    if (Array.isArray(payload)) {
+      entries.push(...payload);
+    } else if (Array.isArray(payload.plugins)) {
+      entries.push(...payload.plugins);
+    } else if (Array.isArray(payload.marketplaces)) {
+      for (const marketplace of payload.marketplaces) {
+        for (const plugin of marketplace.plugins || []) {
+          entries.push({ ...plugin, marketplace: plugin.marketplace || marketplace.name });
+        }
+      }
+    } else {
+      entries.push(...collectEntries(payload));
+    }
+
+    const seen = new Set();
+    return entries
+      .map(entry => normalizeMarketplacePlugin(entry, entry.marketplace))
+      .filter(plugin => {
+        if (!plugin || seen.has(plugin.pluginId)) return false;
+        seen.add(plugin.pluginId);
+        return true;
+      });
+  }
+
+  discoverFromText(initialOutput, options = {}) {
+    const marketplaces = this.listMarketplaces(options);
+    if (marketplaces.length === 0) return [];
+    const results = [];
+    for (const marketplace of marketplaces) {
+      const output = marketplaces.length === 1
+        ? initialOutput
+        : this.run(['plugin', 'discover', marketplace.id, '--json'], options);
+      const lines = stripAnsi(output).split(/\r?\n/);
+      let current = null;
+      for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('Available Plugins')) continue;
+        if (/^No plugins (available|found)/i.test(line)) continue;
+        if (/^\S/.test(rawLine)) continue;
+        if (/^\s{4,}\S/.test(rawLine) && current) {
+          current.description = line;
+          continue;
+        }
+        const match = line.match(/^(.+?)(?:@([^@\s]+))?$/);
+        if (!match) continue;
+        current = normalizeMarketplacePlugin({
+          name: match[1],
+          version: match[2] || 'latest',
+          marketplace: marketplace.id
+        }, marketplace.id);
+        if (current) results.push(current);
+      }
+    }
+    return results;
+  }
+
+  listMarketplaces(options = {}) {
+    const output = this.run(['plugin', 'marketplace', 'list', '--json'], options);
+    const text = stripAnsi(output).trim();
+    if (!text || text.includes('No marketplaces configured')) return [];
+    let payload;
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      const entries = text.split(/\r?\n/)
+        .filter(line => /^\s{2,}\S/.test(line))
+        .map(line => {
+          const match = line.trim().match(/^(\S+)\s+(.+)$/);
+          return match ? { name: match[1], sourceUri: match[2], source: match[2] } : null;
+        })
+        .filter(Boolean);
+      if (entries.length === 0) {
+        throw new Error('OMP returned invalid marketplace list output');
+      }
+      payload = entries;
+    }
+    const entries = Array.isArray(payload)
+      ? payload
+      : (payload.marketplaces || collectEntries(payload));
+    return entries.map(entry => {
+      const name = String(entry.name || entry.id || entry.marketplace || '').trim();
+      const source = entry.source || entry.url || entry.repo || entry.repository || '';
+      return {
+        ...entry,
+        id: name,
+        name,
+        label: name,
+        source,
+        sourceUri: typeof source === 'string' ? source : JSON.stringify(source),
+        provider: 'omp-marketplace',
+        enabled: true,
+        mutable: {
+          toggle: false,
+          auth: false,
+          remove: true,
+          update: true
+        }
+      };
+    }).filter(entry => entry.id);
+  }
+
+  addMarketplace(source, options = {}) {
+    const target = String(source || '').trim();
+    if (!target) throw new Error('Missing marketplace source');
+    this.run(['plugin', 'marketplace', 'add', target], 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);
+    return this.listMarketplaces(options);
+  }
+
+  updateMarketplaces(name = '', options = {}) {
+    const args = ['plugin', 'marketplace', 'update'];
+    if (name) args.push(name);
+    this.run(args, options);
+    return this.listMarketplaces(options);
+  }
+}
+
+module.exports = {
+  OmpNativePluginAdapter,
+  collectEntries,
+  normalizeInstalledPlugin,
+  normalizeMarketplacePlugin,
+  parseJsonOutput
+};

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,