coding-tool-x 3.6.13 → 3.7.1

package/src/server/services/omp-auth-providers.js

@@ -0,0 +1,294 @@
+const { spawnSync } = require('child_process');
+const ompConfig = require('./omp-config');
+
+const COMMAND_TIMEOUT_MS = 5000;
+const TOKEN_LIST_TIMEOUT_MS = 3000;
+const CACHE_TTL_MS = 15000;
+
+const LOGIN_PROVIDER_IDS = new Set([
+  'openai-codex',
+  'openai-codex-device',
+  'anthropic',
+  'github-copilot',
+  'cursor',
+  'devin',
+  'google-antigravity',
+  'google-gemini-cli',
+  'xai-oauth',
+  'gitlab-duo',
+  'gitlab-duo-agent',
+  'alibaba-coding-plan',
+  'zhipu-coding-plan',
+  'kimi-code',
+  'zai',
+  'qwen-portal',
+  'minimax-code',
+  'minimax-code-cn',
+  'perplexity'
+]);
+
+const ACCOUNT_CHECK_PROVIDER_IDS = new Set([
+  'openai-codex',
+  'openai-codex-device',
+  'anthropic',
+  'google-gemini-cli',
+  'github-copilot'
+]);
+
+const PROVIDER_ALIASES = {
+  codex: 'openai-codex',
+  openai: 'openai-codex',
+  'openai-codex': 'openai-codex',
+  'openai-codex-device': 'openai-codex-device',
+  claude: 'anthropic',
+  anthropic: 'anthropic',
+  gemini: 'google-gemini-cli',
+  'gemini-cli': 'google-gemini-cli',
+  'google-gemini-cli': 'google-gemini-cli',
+  copilot: 'github-copilot',
+  'github-copilot': 'github-copilot'
+};
+
+let snapshotCache = {};
+
+function normalizeProviderId(value = '') {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+
+function resolveProviderAlias(value = '') {
+  const id = normalizeProviderId(value);
+  return PROVIDER_ALIASES[id] || id;
+}
+
+function normalizeCommandOutput(value) {
+  if (value === undefined || value === null) return '';
+  return Buffer.isBuffer(value) ? value.toString('utf8') : String(value);
+}
+
+function sanitizeIdentity(value = '') {
+  const text = String(value || '').trim();
+  if (!text) return '';
+  return text
+    .replace(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi, (email) => {
+      const [name, domain] = email.split('@');
+      if (!name || !domain) return '***';
+      const visible = name.length <= 2 ? `${name[0] || '*'}***` : `${name.slice(0, 2)}***${name.slice(-1)}`;
+      return `${visible}@${domain}`;
+    })
+    .replace(/sk-[A-Za-z0-9_-]{8,}/g, 'sk-***')
+    .replace(/nvapi-[A-Za-z0-9_-]{8,}/g, 'nvapi-***')
+    .replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, 'Bearer ***')
+    .replace(/[A-Za-z0-9_-]{24,}\.[A-Za-z0-9_-]{12,}\.[A-Za-z0-9_-]{12,}/g, 'jwt.***')
+    .replace(/[A-Za-z0-9_=-]{32,}/g, '***');
+}
+
+function runCommand(command, args = [], options = {}) {
+  const runner = options.commandRunner || spawnSync;
+  const result = runner(command, args, {
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      ...(options.env || {})
+    },
+    timeout: options.timeout || COMMAND_TIMEOUT_MS
+  });
+  if (typeof result === 'string' || Buffer.isBuffer(result)) {
+    return { status: 0, stdout: normalizeCommandOutput(result), stderr: '' };
+  }
+  return result || { status: 0, stdout: '', stderr: '' };
+}
+
+function parseJsonCommand(command, args, options = {}) {
+  const result = runCommand(command, args, options);
+  const status = result.status === undefined || result.status === null ? 0 : result.status;
+  const stdout = normalizeCommandOutput(result.stdout).trim();
+  const stderr = normalizeCommandOutput(result.stderr).trim();
+  if (result.error) {
+    return { ok: false, status, error: result.error.message, stderr };
+  }
+  if (!stdout) {
+    return { ok: status === 0, status, value: null, stderr };
+  }
+  try {
+    return { ok: status === 0, status, value: JSON.parse(stdout), stderr };
+  } catch (error) {
+    return { ok: false, status, error: error.message, stderr };
+  }
+}
+
+function parseAccountLine(line = '', index) {
+  const sanitized = sanitizeIdentity(line)
+    .replace(/^\s*[-*]\s*/, '')
+    .replace(/^\s*\[?\d+\]?\s*[:.)-]?\s*/, '')
+    .trim();
+  if (!sanitized || /^no oauth accounts found/i.test(sanitized)) return null;
+  return {
+    index: index + 1,
+    identity: sanitized
+  };
+}
+
+function listProviderAccounts(command, providerId, options = {}) {
+  const result = runCommand(command, ['token', providerId, '--list'], {
+    ...options,
+    timeout: options.tokenListTimeout || TOKEN_LIST_TIMEOUT_MS
+  });
+  const status = result.status === undefined || result.status === null ? 0 : result.status;
+  const stdout = normalizeCommandOutput(result.stdout);
+  const stderr = normalizeCommandOutput(result.stderr);
+  const combined = `${stdout}\n${stderr}`;
+
+  if (result.error) {
+    return { checked: true, loggedIn: false, accountCount: 0, accounts: [], error: result.error.message };
+  }
+
+  const accounts = stdout
+    .split(/\r?\n/)
+    .map((line, index) => parseAccountLine(line, index))
+    .filter(Boolean);
+
+  const noAccounts = /no oauth accounts found/i.test(combined);
+  return {
+    checked: true,
+    loggedIn: accounts.length > 0,
+    accountCount: accounts.length,
+    accounts,
+    error: status !== 0 && !noAccounts && accounts.length === 0
+      ? sanitizeIdentity(stderr || stdout || `exit code ${status}`)
+      : null
+  };
+}
+
+function isLikelyLoginProvider(provider = {}) {
+  const id = normalizeProviderId(provider.id);
+  const name = String(provider.name || '').toLowerCase();
+  return LOGIN_PROVIDER_IDS.has(id)
+    || id.includes('oauth')
+    || id.includes('codex')
+    || id.includes('copilot')
+    || id.includes('gemini-cli')
+    || name.includes('subscription')
+    || name.includes('coding plan')
+    || name.includes('token plan')
+    || name.includes('claude pro')
+    || name.includes('chatgpt plus')
+    || name.includes('chatgpt pro');
+}
+
+function normalizeProvider(provider = {}) {
+  const id = normalizeProviderId(provider.id);
+  return {
+    id,
+    name: String(provider.name || provider.id || id),
+    loginCapable: isLikelyLoginProvider(provider)
+  };
+}
+
+function buildEmptySnapshot(runtime, reason) {
+  return {
+    available: false,
+    reason,
+    runtime,
+    brokerStatus: null,
+    gatewayStatus: null,
+    providers: [],
+    supportedProviders: [],
+    aliases: { ...PROVIDER_ALIASES },
+    checkedAt: new Date().toISOString()
+  };
+}
+
+function getOmpAuthProviderSnapshot(options = {}) {
+  const now = Date.now();
+  const cacheKey = options.accountCheck === false
+    ? (options.includeStatus === false ? 'metadata' : 'metadata-status')
+    : 'full';
+  const cached = snapshotCache[cacheKey];
+  if (!options.forceRefresh && cached && now - cached.loadedAt < CACHE_TTL_MS) {
+    return cached.value;
+  }
+
+  const env = options.env || process.env;
+  const runtime = options.runtime || ompConfig.resolveOmpRuntime(env, options.runtimeOptions || {});
+  if (!runtime || runtime.runtime !== 'omp' || !runtime.installed) {
+    const value = buildEmptySnapshot(runtime || null, 'omp-not-available');
+    snapshotCache[cacheKey] = { loadedAt: now, value };
+    return value;
+  }
+
+  const command = runtime.command;
+  const listResult = parseJsonCommand(command, ['auth-broker', 'list', '--json'], options);
+  if (!listResult.ok || !Array.isArray(listResult.value)) {
+    const value = buildEmptySnapshot(runtime, listResult.error || listResult.stderr || 'auth-provider-list-failed');
+    snapshotCache[cacheKey] = { loadedAt: now, value };
+    return value;
+  }
+
+  const supportedProviders = listResult.value
+    .map(normalizeProvider)
+    .filter(provider => provider.id);
+  const loginProviders = supportedProviders
+    .filter(provider => provider.loginCapable)
+    .map(provider => {
+      if (options.accountCheck === false || !ACCOUNT_CHECK_PROVIDER_IDS.has(provider.id)) {
+        return {
+          ...provider,
+          checked: false,
+          loggedIn: null,
+          accountCount: null,
+          accounts: [],
+          error: null
+        };
+      }
+      return {
+        ...provider,
+        ...listProviderAccounts(command, provider.id, options)
+      };
+    });
+
+  const brokerStatus = options.includeStatus === false
+    ? { value: null }
+    : parseJsonCommand(command, ['auth-broker', 'status', '--json'], options);
+  const gatewayStatus = options.includeStatus === false
+    ? { value: null }
+    : parseJsonCommand(command, ['auth-gateway', 'status', '--json'], options);
+
+  const value = {
+    available: true,
+    runtime,
+    brokerStatus: brokerStatus.value || null,
+    gatewayStatus: gatewayStatus.value || null,
+    providers: loginProviders,
+    supportedProviders,
+    aliases: { ...PROVIDER_ALIASES },
+    checkedAt: new Date().toISOString()
+  };
+  snapshotCache[cacheKey] = { loadedAt: now, value };
+  return value;
+}
+
+function findAuthProviderForKey(providerKey, snapshot) {
+  const resolved = resolveProviderAlias(providerKey);
+  const providers = Array.isArray(snapshot?.providers) ? snapshot.providers : [];
+  return providers.find(provider => provider.id === resolved) || null;
+}
+
+function clearOmpAuthProviderCache() {
+  snapshotCache = {};
+}
+
+module.exports = {
+  LOGIN_PROVIDER_IDS,
+  ACCOUNT_CHECK_PROVIDER_IDS,
+  clearOmpAuthProviderCache,
+  findAuthProviderForKey,
+  getOmpAuthProviderSnapshot,
+  normalizeProviderId,
+  resolveProviderAlias,
+  sanitizeIdentity
+};

package/src/server/services/omp-channels.js

@@ -0,0 +1,94 @@
+const { PATHS } = require('../../config/paths');
+const BaseChannelService = require('./base/base-channel-service');
+const {
+  writeManagedOmpProviders,
+  removeManagedOmpProviders,
+  isManagedOmpProvidersActive,
+  getLastManagedOmpSyncResult
+} = require('./omp-settings-manager');
+
+class OmpChannelService extends BaseChannelService {
+  constructor() {
+    super({
+      platform: 'omp',
+      channelsFilePath: PATHS.channels.omp,
+      defaultGatewaySource: 'openai_compatible',
+      isProxyRunning: () => isManagedOmpProvidersActive()
+    });
+  }
+
+  _applyDefaults(channel) {
+    const normalized = super._applyDefaults(channel);
+    normalized.providerKey = normalized.providerKey || normalized.provider || normalized.name || normalized.id;
+    normalized.providerApi = normalized.providerApi || normalized.api || normalized.wireApi || 'openai-completions';
+    normalized.model = normalized.model || null;
+    normalized.models = Array.isArray(normalized.models) ? normalized.models : [];
+    normalized.allowedModels = Array.isArray(normalized.allowedModels) ? normalized.allowedModels : [];
+    normalized.speedTestModel = normalized.speedTestModel || null;
+    normalized.modelRedirects = Array.isArray(normalized.modelRedirects) ? normalized.modelRedirects : [];
+    return normalized;
+  }
+
+  _applyToNativeSettings(channel) {
+    writeManagedOmpProviders([channel]);
+  }
+
+  _onAfterCreate(_channel, allChannels) {
+    this.syncManagedOmpProviders(allChannels);
+  }
+
+  _onAfterUpdate(_oldChannel, _newChannel, allChannels) {
+    this.syncManagedOmpProviders(allChannels);
+  }
+
+  _onAfterDelete(_channel, allChannels) {
+    this.syncManagedOmpProviders(allChannels);
+  }
+
+  syncManagedOmpProviders(channels = this.getChannels().channels) {
+    const enabledChannels = (channels || []).filter(channel => channel.enabled !== false);
+    if (enabledChannels.length === 0) {
+      removeManagedOmpProviders();
+      return getLastManagedOmpSyncResult();
+    }
+    writeManagedOmpProviders(enabledChannels);
+    return getLastManagedOmpSyncResult();
+  }
+
+  disableManagedOmpProviders() {
+    removeManagedOmpProviders();
+    return getLastManagedOmpSyncResult();
+  }
+
+  syncManagedProviderExtension(channels = this.getChannels().channels) {
+    return this.syncManagedOmpProviders(channels);
+  }
+
+  disableManagedProviderExtension() {
+    this.disableManagedOmpProviders();
+  }
+}
+
+const service = new OmpChannelService();
+
+module.exports = {
+  getChannels: () => service.getChannels(),
+  createChannel: (name, baseUrl, apiKey, extra = {}) => service.createChannel({
+    name,
+    baseUrl,
+    apiKey,
+    ...extra
+  }),
+  updateChannel: (id, updates) => service.updateChannel(id, updates),
+  markChannelAsRecentlyUsed: (id) => service.updateChannel(id, {}),
+  deleteChannel: (id) => service.deleteChannel(id),
+  getEnabledChannels: () => service.getEnabledChannels(),
+  saveChannelOrder: (order) => service.saveChannelOrder(order),
+  applyChannelToSettings: (id) => service.applyChannelToSettings(id),
+  disableAllChannels: () => service.disableAllChannels(),
+  getEffectiveApiKey: (channel) => channel?.apiKey || null,
+  syncManagedOmpProviders: (channels) => service.syncManagedOmpProviders(channels),
+  disableManagedOmpProviders: () => service.disableManagedOmpProviders(),
+  syncManagedProviderExtension: (channels) => service.syncManagedProviderExtension(channels),
+  disableManagedProviderExtension: () => service.disableManagedProviderExtension()
+};

package/src/server/services/omp-config.js

@@ -0,0 +1,269 @@
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const yaml = require('js-yaml');
+const { HOME_DIR, PATHS = {} } = require('../../config/paths');
+
+const DEFAULT_OMP_COMMAND = 'omp';
+
+function expandHome(input = '') {
+  const value = String(input || '').trim();
+  if (!value) return '';
+  if (value === '~') return HOME_DIR;
+  if (value.startsWith('~/')) return path.join(HOME_DIR, value.slice(2));
+  return value;
+}
+
+function normalizeProfileName(profile = '') {
+  const value = String(profile || '').trim();
+  if (!value || value === 'default') return '';
+  return value;
+}
+
+function getOmpProfile(env = process.env) {
+  return normalizeProfileName(env.OMP_PROFILE);
+}
+
+function isAbsolutePathLike(value = '') {
+  return path.isAbsolute(value) || /^[a-zA-Z]:[\\/]/.test(value) || String(value).startsWith('\\\\');
+}
+
+function getOmpConfigRoot(env = process.env) {
+  const configured = expandHome(env.OMP_CONFIG_DIR || '');
+  if (!configured) return path.join(HOME_DIR, '.omp');
+  return isAbsolutePathLike(configured) ? configured : path.join(HOME_DIR, configured);
+}
+
+function getDefaultOmpAgentDir(env = process.env) {
+  const configRoot = getOmpConfigRoot(env);
+  const profile = getOmpProfile(env);
+  return profile
+    ? path.join(configRoot, 'profiles', profile, 'agent')
+    : path.join(configRoot, 'agent');
+}
+
+function getFallbackOmpAgentDir(runtime, env = process.env) {
+  const configured = expandHome(env.OMP_CODING_AGENT_DIR || '');
+  if (configured) return configured;
+  return getDefaultOmpAgentDir(env);
+}
+
+function buildCommandEnv(env = process.env) {
+  return {
+    ...process.env,
+    ...env
+  };
+}
+
+function runOmpCommand(command, args = [], env = process.env, options = {}, stdio = ['ignore', 'pipe', 'pipe']) {
+  const runner = options.commandRunner || execFileSync;
+  return runner(command, args, {
+    encoding: 'utf8',
+    env: buildCommandEnv(env),
+    stdio,
+    timeout: options.timeout || 3000
+  });
+}
+
+function readOmpAgentDirFromCommand(command, env = process.env, options = {}) {
+  try {
+    const output = runOmpCommand(command, ['config', 'path'], env, options);
+    const agentDir = String(output || '').trim().split(/\r?\n/).find(Boolean);
+    return agentDir ? path.resolve(expandHome(agentDir)) : '';
+  } catch {
+    return '';
+  }
+}
+
+function getOmpAgentDir(env = process.env, options = {}) {
+  const runtime = options.runtime || resolveOmpRuntime(env, options);
+  if (runtime.runtime === 'omp' && runtime.installed) {
+    const commandAgentDir = readOmpAgentDirFromCommand(runtime.command, env, options);
+    if (commandAgentDir) {
+      return commandAgentDir;
+    }
+  }
+  return path.resolve(expandHome(getFallbackOmpAgentDir(runtime, env)));
+}
+
+function getOmpPaths(env = process.env, options = {}) {
+  const runtime = options.runtime || resolveOmpRuntime(env, options);
+  const agentDir = getOmpAgentDir(env, { ...options, runtime });
+  return {
+    agentDir,
+    config: path.join(agentDir, 'config.yml'),
+    settings: path.join(agentDir, 'config.yml'),
+    settingsJsonLegacy: path.join(agentDir, 'settings.json'),
+    auth: path.join(agentDir, 'auth.json'),
+    models: path.join(agentDir, 'models.yml'),
+    modelsYml: path.join(agentDir, 'models.yml'),
+    modelsJsonLegacy: path.join(agentDir, 'models.json'),
+    mcp: path.join(agentDir, 'mcp.json'),
+    sessions: path.join(agentDir, 'sessions'),
+    skills: path.join(agentDir, 'skills'),
+    prompts: path.join(agentDir, 'prompts'),
+    commands: path.join(agentDir, 'commands'),
+    notes: path.join(agentDir, 'notes'),
+    extensions: path.join(agentDir, 'extensions'),
+    themes: path.join(agentDir, 'themes'),
+    packages: path.join(agentDir, 'packages'),
+    managedProviderExtension: path.join(agentDir, 'extensions', 'coding-tool-x-provider.ts'),
+    managedVisibilityState: path.join(PATHS.storage || path.join(HOME_DIR, '.cc-tool', 'storage'), 'omp-managed-visibility.json')
+  };
+}
+
+function ensureOmpDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function readJsonFile(filePath, fallback = {}) {
+  try {
+    if (!fs.existsSync(filePath)) return fallback;
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return raw.trim() ? JSON.parse(raw) : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJsonFile(filePath, data) {
+  ensureOmpDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, JSON.stringify(data || {}, null, 2), 'utf8');
+}
+
+function readYamlFile(filePath, fallback = {}) {
+  try {
+    if (!fs.existsSync(filePath)) return fallback;
+    const raw = fs.readFileSync(filePath, 'utf8');
+    if (!raw.trim()) return fallback;
+    const parsed = yaml.load(raw);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function writeYamlFile(filePath, data) {
+  ensureOmpDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, yaml.dump(data || {}, {
+    lineWidth: 120,
+    noRefs: true,
+    sortKeys: false
+  }), 'utf8');
+}
+
+function readOmpSettings() {
+  const paths = getOmpPaths();
+  return readYamlFile(paths.settings, readJsonFile(paths.settingsJsonLegacy, {}));
+}
+
+function writeOmpSettings(settings) {
+  writeYamlFile(getOmpPaths().settings, settings || {});
+}
+
+function getOmpCommand(env = process.env) {
+  return String(env.OMP_COMMAND || DEFAULT_OMP_COMMAND).trim() || DEFAULT_OMP_COMMAND;
+}
+
+function commandExists(command, env = process.env, options = {}) {
+  try {
+    runOmpCommand(command, ['--version'], env, options, 'ignore');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function resolveOmpRuntime(env = process.env, options = {}) {
+  const configured = env.OMP_COMMAND;
+  if (configured) {
+    const command = getOmpCommand(env);
+    return {
+      command,
+      runtime: 'omp',
+      installed: commandExists(command, env, options),
+      configured: true,
+      commandSource: 'OMP_COMMAND'
+    };
+  }
+
+  if (commandExists(DEFAULT_OMP_COMMAND, env, options)) {
+    return {
+      command: DEFAULT_OMP_COMMAND,
+      runtime: 'omp',
+      installed: true,
+      configured: false,
+      commandSource: 'path'
+    };
+  }
+
+  return {
+    command: DEFAULT_OMP_COMMAND,
+    runtime: 'omp',
+    installed: false,
+    configured: false,
+    commandSource: 'fallback'
+  };
+}
+
+function isOmpInstalled(env = process.env, options = {}) {
+  const runtime = options.runtime || resolveOmpRuntime(env, options);
+  if (runtime.installed) {
+    return true;
+  }
+  return fs.existsSync(getOmpPaths(env, { ...options, runtime }).agentDir);
+}
+
+function readTextFile(filePath, fallback = '') {
+  try {
+    if (!fs.existsSync(filePath)) return fallback;
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return fallback;
+  }
+}
+
+function getOmpStatus(env = process.env, options = {}) {
+  const runtime = resolveOmpRuntime(env, options);
+  const paths = getOmpPaths(env, { ...options, runtime });
+  return {
+    installed: isOmpInstalled(env, { ...options, runtime }),
+    runtime: runtime.runtime,
+    command: runtime.command,
+    commandSource: runtime.commandSource,
+    agentDir: paths.agentDir,
+    settingsPath: paths.settings,
+    authPath: paths.auth,
+    modelsPath: paths.modelsYml,
+    modelsYmlPath: paths.modelsYml,
+    modelsJsonLegacyPath: paths.modelsJsonLegacy,
+    sessionsDir: paths.sessions,
+    skillsDir: paths.skills,
+    promptsDir: paths.prompts,
+    commandsDir: paths.commands,
+    extensionsDir: paths.extensions,
+    themesDir: paths.themes,
+    packagesDir: paths.packages
+  };
+}
+
+module.exports = {
+  expandHome,
+  getOmpAgentDir,
+  getOmpPaths,
+  ensureOmpDir,
+  readJsonFile,
+  readYamlFile,
+  readTextFile,
+  writeJsonFile,
+  writeYamlFile,
+  readOmpSettings,
+  writeOmpSettings,
+  getOmpCommand,
+  getOmpProfile,
+  resolveOmpRuntime,
+  isOmpInstalled,
+  getOmpStatus
+};