coding-tool-x 3.8.3 → 3.8.5

package/src/{server/services → platforms}/native-oauth-adapters.js

@@ -5,20 +5,50 @@ const crypto = require('crypto');
 const { spawnSync } = require('child_process');
 const toml = require('toml');
 const tomlStringify = require('@iarna/toml').stringify;
-const { NATIVE_PATHS, PATHS } = require('../../config/paths');
-const claudeSettingsManager = require('./settings-manager');
-const codexSettingsManager = require('./codex-settings-manager');
-const geminiSettingsManager = require('./gemini-settings-manager');
-const opencodeSettingsManager = require('./opencode-settings-manager');
-const { syncCodexUserEnvironment } = require('./codex-env-manager');
-const nativeKeychain = require('./native-keychain');
-const { maskToken, decodeJwtPayload, removeFileIfExists, sha256 } = require('./oauth-utils');
-
-const SUPPORTED_TOOLS = ['claude', 'codex', 'gemini', 'opencode', 'omp'];
+const pathsModule = require('../config/paths');
+const DEFAULT_NATIVE_PATHS = pathsModule.NATIVE_PATHS;
+const DEFAULT_PATHS = pathsModule.PATHS;
+let NATIVE_PATHS = DEFAULT_NATIVE_PATHS;
+let PATHS = DEFAULT_PATHS;
+const claudeSettingsManager = require('./drivers/claude/native-config-implementation');
+const codexSettingsManager = require('./drivers/codex/native-config-implementation');
+const geminiSettingsManager = require('./drivers/gemini/native-config-implementation');
+const { syncCodexUserEnvironment } = require('./drivers/codex/env-manager');
+const nativeKeychain = require('../server/services/native-keychain');
+const { maskToken, decodeJwtPayload, removeFileIfExists, sha256 } = require('../server/services/oauth-utils');
+
+const SUPPORTED_TOOLS = ['claude', 'codex', 'gemini', 'omp'];
 const GEMINI_MAIN_ACCOUNT_KEY = 'main-account';
 const GEMINI_KEYCHAIN_SERVICE = 'gemini-cli-oauth';
 const CODEX_KEYCHAIN_SERVICE = 'Codex Auth';
 
+function configure({ pathContext } = {}) {
+  if (!pathContext?.customized) {
+    NATIVE_PATHS = DEFAULT_NATIVE_PATHS;
+    PATHS = DEFAULT_PATHS;
+    return;
+  }
+
+  const platform = String(pathContext.platform || '').trim().toLowerCase();
+  const native = pathContext.native && typeof pathContext.native === 'object'
+    ? pathContext.native
+    : {};
+  const state = pathContext.state && typeof pathContext.state === 'object'
+    ? pathContext.state
+    : {};
+  NATIVE_PATHS = {
+    ...DEFAULT_NATIVE_PATHS,
+    ...(platform ? { [platform]: { ...(DEFAULT_NATIVE_PATHS[platform] || {}), ...native } } : {})
+  };
+  PATHS = {
+    ...DEFAULT_PATHS,
+    channels: {
+      ...(DEFAULT_PATHS.channels || {}),
+      ...(platform && state.channels ? { [platform]: state.channels } : {})
+    }
+  };
+}
+
 function ensureDir(dirPath) {
   if (!dirPath) return;
   fs.mkdirSync(dirPath, { recursive: true });
@@ -152,8 +182,37 @@ function clearClaudeOAuth() {
   settings.env = settings.env || {};
   delete settings.env.ANTHROPIC_AUTH_TOKEN;
   delete settings.env.CLAUDE_CODE_OAUTH_TOKEN;
+  ensureDir(path.dirname(NATIVE_PATHS.claude.settings));
   claudeSettingsManager.writeSettings(settings);
 }
+function clearClaudeChannelConfig() {
+  let settings = {};
+  try {
+    settings = claudeSettingsManager.settingsExists()
+      ? claudeSettingsManager.readSettings()
+      : {};
+  } catch {
+    settings = {};
+  }
+
+  settings.env = settings.env || {};
+  [
+    'ANTHROPIC_BASE_URL',
+    'ANTHROPIC_API_KEY',
+    'ANTHROPIC_AUTH_TOKEN',
+    'CLAUDE_CODE_OAUTH_TOKEN',
+    'ANTHROPIC_MODEL',
+    'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+    'ANTHROPIC_DEFAULT_SONNET_MODEL',
+    'ANTHROPIC_DEFAULT_OPUS_MODEL'
+  ].forEach((key) => {
+    delete settings.env[key];
+  });
+  delete settings.apiKeyHelper;
+  ensureDir(path.dirname(NATIVE_PATHS.claude.settings));
+  claudeSettingsManager.writeSettings(settings);
+}
+
 
 function applyClaudeOAuth(credential) {
   clearClaudeOAuth();
@@ -199,7 +258,7 @@ function applyClaudeOAuth(credential) {
 }
 
 function inspectClaudeState() {
-  const { getProxyStatus } = require('../proxy-server');
+  const { getProxyStatus } = require('./drivers/claude/proxy-implementation');
   const proxyStatus = getProxyStatus();
   const nativeOAuth = readClaudeNativeOAuth();
 
@@ -379,7 +438,7 @@ function applyCodexOAuth(credential) {
 }
 
 function inspectCodexState() {
-  const { getCodexProxyStatus } = require('../codex-proxy-server');
+  const { getCodexProxyStatus } = require('./drivers/codex/proxy-implementation');
   const proxyStatus = getCodexProxyStatus();
   const nativeOAuth = readCodexNativeOAuth();
 
@@ -536,6 +595,7 @@ function clearGeminiOAuth() {
 }
 
 function clearGeminiChannelConfig() {
+  ensureDir(path.dirname(NATIVE_PATHS.gemini.env));
   const env = geminiSettingsManager.configExists()
     ? geminiSettingsManager.readEnv()
     : {};
@@ -597,7 +657,7 @@ function applyGeminiOAuth(credential) {
 }
 
 function inspectGeminiState() {
-  const { getGeminiProxyStatus } = require('../gemini-proxy-server');
+  const { getGeminiProxyStatus } = require('./drivers/gemini/proxy-implementation');
   const proxyStatus = getGeminiProxyStatus();
   const nativeOAuth = readGeminiNativeOAuth();
 
@@ -628,388 +688,10 @@ function inspectGeminiState() {
   };
 }
 
-function parseOpenCodeOAuthPayload(raw) {
-  if (!raw || typeof raw !== 'object') {
-    return null;
-  }
-
-  if (raw.type === 'oauth' || raw.access) {
-    return parseOpenCodeOAuthEntry(raw.providerId, raw);
-  }
-
-  if (raw.openai && typeof raw.openai === 'object') {
-    return parseOpenCodeOAuthEntry('openai', raw.openai);
-  }
-
-  for (const [providerId, value] of Object.entries(raw)) {
-    const parsed = parseOpenCodeOAuthEntry(providerId, value);
-    if (parsed) {
-      return parsed;
-    }
-  }
-
-  return null;
-}
-
-function parseOpenCodeOAuthEntry(providerId, target) {
-  const normalizedProviderId = String(providerId || 'openai').trim() || 'openai';
-
-  if (!target || target.type !== 'oauth' || !target.access) {
-    return null;
-  }
-
-  return {
-    providerId: normalizedProviderId,
-    accessToken: String(target.access || '').trim(),
-    refreshToken: String(target.refresh || '').trim() || '',
-    expiresAt: Number(target.expires || 0) || null,
-    accountId: String(target.accountId || '').trim() || '',
-    enterpriseUrl: String(target.enterpriseUrl || '').trim() || '',
-    primaryToken: String(target.access || '').trim()
-  };
-}
-
-function getActiveOpenCodeProviderId() {
-  try {
-    const configPath = opencodeSettingsManager.selectConfigPath();
-    if (!configPath || !fs.existsSync(configPath)) {
-      return '';
-    }
-
-    const config = opencodeSettingsManager.readConfig(configPath);
-    const modelRef = String(config?.model || '').trim();
-    if (modelRef.includes('/')) {
-      return modelRef.split('/')[0].trim();
-    }
-
-    const providerIds = config?.provider && typeof config.provider === 'object'
-      ? Object.keys(config.provider).filter(Boolean)
-      : [];
-    return providerIds.length === 1 ? providerIds[0] : '';
-  } catch {
-    return '';
-  }
-}
-
-function readAllOpenCodeNativeOAuth() {
-  const payload = readJsonFile(NATIVE_PATHS.opencode.auth, null);
-  if (!payload || typeof payload !== 'object') {
-    return [];
-  }
-
-  const activeProviderId = getActiveOpenCodeProviderId();
-  const credentials = Object.entries(payload)
-    .map(([providerId, value]) => parseOpenCodeOAuthEntry(providerId, value))
-    .filter(Boolean)
-    .map((entry) => ({ ...entry, storage: 'auth-file' }));
-
-  if (!activeProviderId || credentials.length <= 1) {
-    return credentials;
-  }
-
-  return credentials.sort((left, right) => {
-    if (left.providerId === activeProviderId) return -1;
-    if (right.providerId === activeProviderId) return 1;
-    return left.providerId.localeCompare(right.providerId);
-  });
-}
-
-function readOpenCodeNativeOAuth() {
-  return readAllOpenCodeNativeOAuth()[0] || null;
-}
-
-function clearOpenCodeOAuth() {
-  const payload = readJsonFile(NATIVE_PATHS.opencode.auth, {});
-  if (!payload || typeof payload !== 'object') {
-    return;
-  }
-
-  const removedProviderIds = [];
-  Object.keys(payload).forEach((providerId) => {
-    if (payload[providerId]?.type === 'oauth') {
-      removedProviderIds.push(providerId);
-      delete payload[providerId];
-    }
-  });
-
-  if (Object.keys(payload).length === 0) {
-    removeFileIfExists(NATIVE_PATHS.opencode.auth);
-  } else {
-    writeJsonFile(NATIVE_PATHS.opencode.auth, payload);
-  }
-
-  syncOpenCodeConfigAfterOAuthRemoval(removedProviderIds);
-}
-
-function disableOpenCodeOAuthCredential(credential = {}) {
-  const providerId = String(credential.providerId || '').trim();
-  const accessToken = String(credential.accessToken || credential.primaryToken || '').trim();
-  const payload = readJsonFile(NATIVE_PATHS.opencode.auth, {});
-  if (!payload || typeof payload !== 'object') {
-    return;
-  }
-
-  const removedProviderIds = [];
-  Object.keys(payload).forEach((key) => {
-    const target = payload[key];
-    if (!target || target.type !== 'oauth') {
-      return;
-    }
-
-    const providerMatched = providerId && key === providerId;
-    const tokenMatched = accessToken && String(target.access || '').trim() === accessToken;
-    if (providerMatched || tokenMatched) {
-      removedProviderIds.push(key);
-      delete payload[key];
-    }
-  });
-
-  if (Object.keys(payload).length === 0) {
-    removeFileIfExists(NATIVE_PATHS.opencode.auth);
-  } else {
-    writeJsonFile(NATIVE_PATHS.opencode.auth, payload);
-  }
-
-  syncOpenCodeConfigAfterOAuthRemoval(removedProviderIds);
-}
-
-function isManagedOpenCodeProvider(provider) {
-  if (!provider || typeof provider !== 'object') {
-    return false;
-  }
-
-  if (provider.__ctx_managed__ === true) {
-    return true;
-  }
-
-  const apiKey = String(provider?.options?.apiKey || '').trim();
-  const baseUrl = String(provider?.options?.baseURL || '').trim();
-  return apiKey === 'PROXY_KEY' && (baseUrl.includes('127.0.0.1') || baseUrl.includes('localhost'));
-}
-
-function isProxyBackedOpenCodeProvider(provider) {
-  if (!provider || typeof provider !== 'object') {
-    return false;
-  }
-
-  const apiKey = String(provider?.options?.apiKey || '').trim();
-  const baseUrl = String(provider?.options?.baseURL || '').trim();
-  return apiKey === 'PROXY_KEY' && (baseUrl.includes('127.0.0.1') || baseUrl.includes('localhost'));
-}
-
-function isMeaningfulOpenCodeProvider(provider) {
-  if (!provider || typeof provider !== 'object') {
-    return false;
-  }
-
-  if (provider.__ctx_managed__ === true) {
-    return true;
-  }
-
-  if (typeof provider.npm === 'string' && provider.npm.trim()) {
-    return true;
-  }
-
-  if (typeof provider.name === 'string' && provider.name.trim()) {
-    return true;
-  }
-
-  if (provider.options && typeof provider.options === 'object' && Object.keys(provider.options).length > 0) {
-    return true;
-  }
-
-  if (provider.models && typeof provider.models === 'object' && Object.keys(provider.models).length > 0) {
-    return true;
-  }
-
-  return false;
-}
-
-function clearOpenCodeManagedModelSelection(config) {
-  const modelRef = String(config?.model || '').trim();
-  if (!modelRef || !modelRef.includes('/')) {
-    return;
-  }
-
-  const providerId = modelRef.split('/')[0].trim();
-  if (!providerId) {
-    return;
-  }
-
-  const provider = config?.provider?.[providerId];
-  if (isManagedOpenCodeProvider(provider)) {
-    delete config.model;
-  }
-}
-
-function getConfiguredOpenCodeProviderId(config) {
-  const modelRef = String(config?.model || '').trim();
-  if (modelRef.includes('/')) {
-    return modelRef.split('/')[0].trim();
-  }
-
-  const providerIds = config?.provider && typeof config.provider === 'object'
-    ? Object.keys(config.provider).filter(Boolean)
-    : [];
-  return providerIds.length === 1 ? providerIds[0] : '';
-}
-
-function buildOpenCodeModelRef(providerId, provider) {
-  if (!providerId || !provider || typeof provider !== 'object') {
-    return '';
-  }
-
-  const modelIds = provider.models && typeof provider.models === 'object'
-    ? Object.keys(provider.models).filter(Boolean)
-    : [];
-
-  if (modelIds.length === 0) {
-    return '';
-  }
-
-  return `${providerId}/${modelIds[0]}`;
-}
-
-function pickFallbackOpenCodeModel(config, excludedProviderIds = new Set()) {
-  const providers = config?.provider && typeof config.provider === 'object'
-    ? Object.entries(config.provider)
-    : [];
-
-  for (const [providerId, provider] of providers) {
-    if (excludedProviderIds.has(providerId)) {
-      continue;
-    }
-
-    const modelRef = buildOpenCodeModelRef(providerId, provider);
-    if (modelRef) {
-      return modelRef;
-    }
-  }
-
-  return '';
-}
-
-function syncOpenCodeConfigAfterOAuthRemoval(removedProviderIds = []) {
-  const removedIds = new Set((removedProviderIds || []).filter(Boolean));
-  if (removedIds.size === 0) {
-    return;
-  }
-
-  const configPath = opencodeSettingsManager.selectConfigPath();
-  if (!configPath || !fs.existsSync(configPath)) {
-    return;
-  }
-
-  let config = {};
-  try {
-    config = opencodeSettingsManager.readConfig(configPath);
-  } catch {
-    return;
-  }
-
-  config = config && typeof config === 'object' ? config : {};
-  config.provider = config.provider && typeof config.provider === 'object' ? config.provider : {};
-
-  let changed = false;
-  for (const providerId of removedIds) {
-    const provider = config.provider[providerId];
-    if (provider && !isMeaningfulOpenCodeProvider(provider)) {
-      delete config.provider[providerId];
-      changed = true;
-    }
-  }
-
-  const activeProviderId = getConfiguredOpenCodeProviderId(config);
-  if (activeProviderId && removedIds.has(activeProviderId)) {
-    const activeProvider = config.provider[activeProviderId];
-    if (!isMeaningfulOpenCodeProvider(activeProvider)) {
-      const fallbackModel = pickFallbackOpenCodeModel(config, removedIds);
-      if (fallbackModel) {
-        config.model = fallbackModel;
-      } else {
-        delete config.model;
-      }
-      changed = true;
-    }
-  }
-
-  if (Object.keys(config.provider).length === 0) {
-    delete config.provider;
-    changed = true;
-  }
-
-  if (changed) {
-    opencodeSettingsManager.writeConfig(configPath, config);
-  }
-}
-
-function applyOpenCodeOAuth(credential) {
-  const providerId = String(credential.providerId || 'openai').trim() || 'openai';
-  const payload = readJsonFile(NATIVE_PATHS.opencode.auth, {});
-  payload[providerId] = {
-    type: 'oauth',
-    access: credential.accessToken,
-    refresh: credential.refreshToken || '',
-    expires: credential.expiresAt || null,
-    accountId: credential.accountId || undefined,
-    enterpriseUrl: credential.enterpriseUrl || undefined
-  };
-  writeJsonFile(NATIVE_PATHS.opencode.auth, payload);
-
-  const configPath = opencodeSettingsManager.selectConfigPath();
-  const config = fs.existsSync(configPath)
-    ? opencodeSettingsManager.readConfig(configPath)
-    : {};
-  config.provider = config.provider && typeof config.provider === 'object' ? config.provider : {};
-  config.provider[providerId] = config.provider[providerId] && typeof config.provider[providerId] === 'object'
-    ? config.provider[providerId]
-    : {};
-  // Preserve existing ctx-managed API providers for OpenCode coexistence, but
-  // drop the active managed selection so OAuth-backed providers become available.
-  clearOpenCodeManagedModelSelection(config);
-  opencodeSettingsManager.writeConfig(configPath, config);
-
-  return { storage: 'auth-file' };
-}
-
-function inspectOpenCodeState() {
-  const { getOpenCodeProxyStatus } = require('../opencode-proxy-server');
-  const proxyStatus = getOpenCodeProxyStatus();
-  const nativeOAuth = readOpenCodeNativeOAuth();
-
-  let channelConfigured = false;
-  try {
-    const configPath = opencodeSettingsManager.selectConfigPath();
-    const config = fs.existsSync(configPath)
-      ? opencodeSettingsManager.readConfig(configPath)
-      : {};
-    const providers = config?.provider && typeof config.provider === 'object'
-      ? Object.values(config.provider)
-      : [];
-    channelConfigured = providers.some(provider => (
-      isMeaningfulOpenCodeProvider(provider) && !isProxyBackedOpenCodeProvider(provider)
-    ));
-  } catch {
-    channelConfigured = false;
-  }
-
-  return {
-    tool: 'opencode',
-    mode: proxyStatus.running
-      ? 'proxy'
-      : (nativeOAuth && channelConfigured
-          ? 'mixed'
-          : (nativeOAuth ? 'oauth' : (channelConfigured ? 'channel' : 'idle'))),
-    proxyRunning: proxyStatus.running,
-    oauthPresent: Boolean(nativeOAuth),
-    channelConfigured,
-    nativeCredential: nativeOAuth ? buildNativeSummary(nativeOAuth) : null
-  };
-}
 
 function resolveOmpRuntime() {
   try {
-    const ompConfig = require('./omp-config');
+    const ompConfig = require('./drivers/omp/config');
     const runtime = ompConfig.resolveOmpRuntime(process.env, {});
     return runtime && runtime.runtime === 'omp' && runtime.installed ? runtime : null;
   } catch {
@@ -1045,7 +727,7 @@ function runOmpCommand(args = [], options = {}) {
 
 function getOmpAuthSnapshot(options = {}) {
   try {
-    const { getOmpAuthProviderSnapshot } = require('./omp-auth-providers');
+    const { getOmpAuthProviderSnapshot } = require('./drivers/omp/auth-providers');
     return getOmpAuthProviderSnapshot({
       accountCheck: true,
       includeStatus: false,
@@ -1065,13 +747,11 @@ function readAllOmpNativeOAuth() {
   return snapshot.providers
     .filter(provider => provider?.loggedIn || Number(provider?.accountCount || 0) > 0)
     .flatMap((provider) => {
-      const accounts = Array.isArray(provider.accounts) && provider.accounts.length > 0
-        ? provider.accounts
-        : [{ index: 1, identity: '' }];
+      const accounts = Array.isArray(provider.accounts) ? provider.accounts : [];
       return accounts.map((account) => ({
         providerId: provider.id,
-        accountId: String(account.index || '').trim(),
-        accountEmail: String(account.identity || '').trim(),
+        accountId: String(account.index || account.id || account.accountId || '').trim(),
+        accountEmail: String(account.identity || account.email || account.accountEmail || '').trim(),
         storage: 'auth-broker',
         primaryToken: ''
       }));
@@ -1089,7 +769,7 @@ function clearOmpOAuth() {
     runOmpCommand(['auth-broker', 'logout', providerId], { timeout: 10000 });
   });
   try {
-    require('./omp-auth-providers').clearOmpAuthProviderCache();
+    require('./drivers/omp/auth-providers').clearOmpAuthProviderCache();
   } catch {
     // cache invalidation is best-effort
   }
@@ -1103,7 +783,7 @@ function disableOmpOAuthCredential(credential = {}) {
   }
   runOmpCommand(['auth-broker', 'logout', providerId], { timeout: 10000 });
   try {
-    require('./omp-auth-providers').clearOmpAuthProviderCache();
+    require('./drivers/omp/auth-providers').clearOmpAuthProviderCache();
   } catch {
     // cache invalidation is best-effort
   }
@@ -1164,7 +844,7 @@ function applyOmpOAuth(credential = {}) {
       throw new Error(`OMP auth-broker import failed: ${detail}`);
     }
     try {
-      require('./omp-auth-providers').clearOmpAuthProviderCache();
+      require('./drivers/omp/auth-providers').clearOmpAuthProviderCache();
     } catch {
       // cache invalidation is best-effort
     }
@@ -1180,8 +860,8 @@ function applyOmpOAuth(credential = {}) {
 }
 
 function inspectOmpState() {
-  const { getOmpProxyStatus } = require('../omp-proxy-server');
-  const { isManagedOmpProvidersActive } = require('./omp-settings-manager');
+  const { getOmpProxyStatus } = require('./drivers/omp/proxy-implementation');
+  const { isManagedOmpProvidersActive } = require('./drivers/omp/native-config-implementation');
   const proxyStatus = getOmpProxyStatus();
   const nativeCredentials = readAllOmpNativeOAuth();
 
@@ -1212,8 +892,6 @@ function inspectTool(tool) {
       return inspectCodexState();
     case 'gemini':
       return inspectGeminiState();
-    case 'opencode':
-      return inspectOpenCodeState();
     case 'omp':
       return inspectOmpState();
     default:
@@ -1229,8 +907,6 @@ function readNativeOAuth(tool) {
       return readCodexNativeOAuth();
     case 'gemini':
       return readGeminiNativeOAuth();
-    case 'opencode':
-      return readOpenCodeNativeOAuth();
     case 'omp':
       return readOmpNativeOAuth();
     default:
@@ -1252,8 +928,6 @@ function readAllNativeOAuth(tool) {
       const credential = readGeminiNativeOAuth();
       return credential ? [credential] : [];
     }
-    case 'opencode':
-      return readAllOpenCodeNativeOAuth();
     case 'omp':
       return readAllOmpNativeOAuth();
     default:
@@ -1272,9 +946,6 @@ function clearNativeOAuth(tool) {
     case 'gemini':
       clearGeminiOAuth();
       return;
-    case 'opencode':
-      clearOpenCodeOAuth();
-      return;
     case 'omp':
       clearOmpOAuth();
       return;
@@ -1294,9 +965,6 @@ function disableNativeOAuthCredential(tool, credential = {}) {
     case 'gemini':
       clearGeminiOAuth();
       return;
-    case 'opencode':
-      disableOpenCodeOAuthCredential(credential);
-      return;
     case 'omp':
       disableOmpOAuthCredential(credential);
       return;
@@ -1313,8 +981,6 @@ function applyOAuthCredential(tool, credential) {
       return applyCodexOAuth(credential);
     case 'gemini':
       return applyGeminiOAuth(credential);
-    case 'opencode':
-      return applyOpenCodeOAuth(credential);
     case 'omp':
       return applyOmpOAuth(credential);
     default:
@@ -1324,10 +990,14 @@ function applyOAuthCredential(tool, credential) {
 
 module.exports = {
   SUPPORTED_TOOLS,
+  configure,
   fingerprintFor,
   inspectTool,
   readNativeOAuth,
   readAllNativeOAuth,
+  clearClaudeChannelConfig,
+  clearGeminiChannelConfig,
+  clearCodexChannelConfig,
   clearNativeOAuth,
   disableNativeOAuthCredential,
   applyOAuthCredential