coding-tool-x 3.8.4 → 3.8.6

package/src/shared/mcp-format.js

@@ -0,0 +1,189 @@
+'use strict';
+
+const STREAMABLE_HTTP_TYPE = 'streamable_http';
+const REMOTE_MCP_SERVER_TYPES = [STREAMABLE_HTTP_TYPE, 'sse'];
+
+function copyCommonMcpFields(source, target) {
+  for (const key of ['timeout', 'auth', 'oauth']) {
+    if (source?.[key] !== undefined) target[key] = source[key];
+  }
+  return target;
+}
+
+const CODEX_PASSTHROUGH_FIELDS = [
+  'enabled',
+  'required',
+  'enabled_tools',
+  'disabled_tools',
+  'startup_timeout_sec',
+  'tool_timeout_sec',
+  'default_tools_approval_mode',
+  'tools',
+  'env_vars',
+  'experimental_environment',
+  'bearer_token_env_var',
+  'oauth'
+];
+
+function copyFields(source, target, fields) {
+  for (const key of fields) {
+    if (source?.[key] !== undefined) target[key] = source[key];
+  }
+  return target;
+}
+
+function convertToCodexFormat(spec = {}) {
+  const result = { type: spec.type || 'stdio' };
+
+  if (result.type === 'stdio') {
+    result.command = spec.command || '';
+    if (Array.isArray(spec.args) && spec.args.length > 0) result.args = spec.args;
+    if (spec.env && Object.keys(spec.env).length > 0) result.env = spec.env;
+    if (spec.cwd) result.cwd = spec.cwd;
+  } else if (REMOTE_MCP_SERVER_TYPES.includes(result.type)) {
+    result.url = spec.url || '';
+    if (spec.headers && Object.keys(spec.headers).length > 0) result.http_headers = spec.headers;
+  }
+
+  copyFields(spec, result, CODEX_PASSTHROUGH_FIELDS);
+  return result;
+}
+
+function convertFromCodexFormat(spec = {}) {
+  const result = { type: spec.type || 'stdio' };
+
+  if (result.type === 'stdio') {
+    result.command = spec.command || '';
+    if (spec.args) result.args = spec.args;
+    if (spec.env) result.env = spec.env;
+    if (spec.cwd) result.cwd = spec.cwd;
+  } else if (REMOTE_MCP_SERVER_TYPES.includes(result.type)) {
+    result.url = spec.url || '';
+    if (spec.http_headers) result.headers = spec.http_headers;
+    else if (spec.headers) result.headers = spec.headers;
+  }
+  copyFields(spec, result, CODEX_PASSTHROUGH_FIELDS);
+  return result;
+}
+
+function extractServerSpec(spec = {}) {
+  const result = { ...spec };
+  for (const key of ['id', 'name', 'description', 'tags', 'homepage', 'docs', 'apps', 'createdAt', 'updatedAt']) {
+    delete result[key];
+  }
+  return result;
+}
+
+function convertToOmpMcpFormat(spec = {}) {
+  const sourceType = spec.type || 'stdio';
+  let result;
+
+  if (sourceType === 'stdio') {
+    result = { type: 'stdio', command: spec.command || '' };
+    if (Array.isArray(spec.args) && spec.args.length > 0) result.args = spec.args;
+    if (spec.env && Object.keys(spec.env).length > 0) result.env = spec.env;
+    if (spec.cwd) result.cwd = spec.cwd;
+  } else if (sourceType === STREAMABLE_HTTP_TYPE) {
+    result = { type: 'http', url: spec.url || '' };
+    if (spec.headers && Object.keys(spec.headers).length > 0) result.headers = spec.headers;
+  } else if (sourceType === 'sse') {
+    result = { type: 'sse', url: spec.url || '' };
+    if (spec.headers && Object.keys(spec.headers).length > 0) result.headers = spec.headers;
+  } else {
+    result = extractServerSpec(spec);
+  }
+
+  return copyCommonMcpFields(spec, result);
+}
+
+function convertFromOmpMcpFormat(spec = {}) {
+  const sourceType = spec.type || 'stdio';
+  let result;
+
+  if (sourceType === 'stdio') {
+    result = { type: 'stdio', command: spec.command || '' };
+    if (spec.args) result.args = spec.args;
+    if (spec.env) result.env = spec.env;
+    if (spec.cwd) result.cwd = spec.cwd;
+  } else if (sourceType === 'http') {
+    result = { type: STREAMABLE_HTTP_TYPE, url: spec.url || '' };
+    if (spec.headers) result.headers = spec.headers;
+  } else if (sourceType === 'sse') {
+    result = { type: 'sse', url: spec.url || '' };
+    if (spec.headers) result.headers = spec.headers;
+  } else {
+    result = convertFromCodexFormat(spec);
+  }
+
+  return copyCommonMcpFields(spec, result);
+}
+
+function convertToOpenCodeFormat(spec = {}) {
+  const sourceType = spec.type || 'stdio';
+
+  if (sourceType === 'local' || sourceType === 'remote') {
+    const result = { ...spec };
+    result.enabled = spec.enabled !== false;
+    if (sourceType === 'local' && typeof result.command === 'string') {
+      result.command = result.command ? [result.command] : [];
+    }
+    return result;
+  }
+
+  if (sourceType === 'stdio') {
+    const command = [];
+    if (spec.command) command.push(spec.command);
+    if (Array.isArray(spec.args) && spec.args.length > 0) command.push(...spec.args);
+
+    const result = { type: 'local', command, enabled: true };
+    if (spec.env && Object.keys(spec.env).length > 0) result.environment = spec.env;
+    if (spec.cwd) result.cwd = spec.cwd;
+    return result;
+  }
+
+  const result = { type: 'remote', url: spec.url || '', enabled: true };
+  if (spec.headers && Object.keys(spec.headers).length > 0) result.headers = spec.headers;
+  return result;
+}
+
+function convertFromOpenCodeFormat(spec = {}) {
+  const sourceType = spec.type || (Array.isArray(spec.command) ? 'local' : 'remote');
+
+  if (sourceType === 'local') {
+    const result = { type: 'stdio' };
+    if (Array.isArray(spec.command) && spec.command.length > 0) {
+      result.command = spec.command[0];
+      if (spec.command.length > 1) result.args = spec.command.slice(1);
+    } else if (typeof spec.command === 'string') {
+      result.command = spec.command;
+    } else {
+      result.command = '';
+    }
+    if (spec.environment && typeof spec.environment === 'object') result.env = spec.environment;
+    else if (spec.env && typeof spec.env === 'object') result.env = spec.env;
+    if (spec.cwd) result.cwd = spec.cwd;
+    return result;
+  }
+
+  if (sourceType === 'remote') {
+    const result = { type: STREAMABLE_HTTP_TYPE, url: spec.url || '' };
+    if (spec.headers && typeof spec.headers === 'object') result.headers = spec.headers;
+    return result;
+  }
+
+  if (sourceType === 'stdio' || REMOTE_MCP_SERVER_TYPES.includes(sourceType)) {
+    return convertFromCodexFormat(spec);
+  }
+
+  return { type: 'stdio', command: '' };
+}
+
+module.exports = {
+  extractServerSpec,
+  convertToCodexFormat,
+  convertFromCodexFormat,
+  convertToOpenCodeFormat,
+  convertFromOpenCodeFormat,
+  convertToOmpMcpFormat,
+  convertFromOmpMcpFormat
+};

package/src/shared/platforms.js

@@ -1,201 +1,138 @@
-const BUILT_IN_CLI_PLATFORMS = [
-  {
-    key: 'claude',
-    title: 'ClaudeCode',
-    label: 'Claude Code',
-    command: 'claude',
-    color: '#18a058',
-    defaultVisible: true,
-    supportsManagedChannels: true,
-    supportsManagedConfig: true,
-    supportsProxy: true,
-    supportsProjects: true,
-    supportsSessions: true,
-    supportsSkills: true,
-    supportsCommands: true,
-    supportsPlugins: true,
-    supportsAgents: true
-  },
-  {
-    key: 'codex',
-    title: 'Codex-CLI',
-    label: 'Codex',
-    command: 'codex',
-    color: '#3b82f6',
-    defaultVisible: true,
-    supportsManagedChannels: true,
-    supportsManagedConfig: true,
-    supportsProxy: true,
-    supportsProjects: true,
-    supportsSessions: true,
-    supportsSkills: true,
-    supportsCommands: true,
-    supportsPlugins: true,
-    supportsAgents: true
-  },
-  {
-    key: 'gemini',
-    title: 'Gemini-CLI',
-    label: 'Gemini',
-    command: 'gemini',
-    color: '#a855f7',
-    defaultVisible: true,
-    supportsManagedChannels: true,
-    supportsManagedConfig: true,
-    supportsProxy: true,
-    supportsProjects: true,
-    supportsSessions: true,
-    supportsSkills: true,
-    supportsCommands: true,
-    supportsPlugins: false,
-    supportsAgents: true
-  },
-  {
-    key: 'opencode',
-    title: 'OpenCode',
-    label: 'OpenCode',
-    command: 'opencode',
-    color: '#ea580c',
-    defaultVisible: true,
-    supportsManagedChannels: true,
-    supportsManagedConfig: true,
-    supportsProxy: true,
-    supportsProjects: true,
-    supportsSessions: true,
-    supportsSkills: true,
-    supportsCommands: true,
-    supportsPlugins: true,
-    supportsAgents: true
-  },
-  {
-    key: 'omp',
-    title: 'OMP',
-    label: 'OMP',
-    command: 'omp',
-    color: '#0f9f9a',
-    defaultVisible: false,
-    supportsManagedChannels: true,
-    supportsManagedConfig: true,
-    supportsProxy: true,
-    supportsProjects: true,
-    supportsSessions: true,
-    supportsSkills: true,
-    supportsCommands: true,
-    supportsPlugins: true,
-    supportsAgents: false
-  }
-];
+const { BUILT_IN_MANIFESTS } = require('../platforms/registry');
 
-const DEFAULT_HOME_CLI_COLUMNS = ['claude', 'codex', 'gemini', 'opencode'];
-const MAX_HOME_CLI_COLUMNS = 4;
-function normalizePlatformKey(value = '') {
-  return String(value || '').trim().toLowerCase();
-}
+const DEFAULT_ENABLED_CLI_PLATFORMS = BUILT_IN_MANIFESTS
+  .filter(manifest => manifest.defaultEnabled !== false)
+  .sort((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0))
+  .map(manifest => manifest.key);
 
-function getBuiltInPlatformKeys() {
-  return BUILT_IN_CLI_PLATFORMS.map(platform => platform.key);
+function capabilityEnabled(manifest, capability) {
+  const driver = manifest?.capabilities?.[capability];
+  return driver !== undefined && driver !== null && driver !== 'unsupported';
 }
 
-function getPlatformDefinition(key) {
-  const normalizedKey = normalizePlatformKey(key);
-  return BUILT_IN_CLI_PLATFORMS.find(platform => platform.key === normalizedKey) || null;
-}
+const BUILT_IN_CLI_PLATFORMS = BUILT_IN_MANIFESTS
+  .slice()
+  .sort((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0))
+  .map(manifest => ({
+    key: manifest.key,
+    title: manifest.title || manifest.label || manifest.key,
+    label: manifest.label || manifest.title || manifest.key,
+    command: manifest.command || manifest.key,
+    color: manifest.color || '',
+    defaultVisible: manifest.defaultVisible !== false,
+    defaultEnabled: manifest.defaultEnabled !== false,
+    sortOrder: manifest.sortOrder || 0,
+    modelCatalogKey: manifest.modelConfig?.catalogKey || manifest.key,
+    portKey: manifest.portKey || null,
+    defaultPort: manifest.defaultPort || null,
+    portLabel: manifest.portLabel || null,
+    apiPrefix: manifest.api?.prefix || null,
+    supportsManagedChannels: capabilityEnabled(manifest, 'channels'),
+    supportsManagedConfig: capabilityEnabled(manifest, 'nativeConfig'),
+    supportsProxy: capabilityEnabled(manifest, 'proxy'),
+    supportsProjects: capabilityEnabled(manifest, 'projects'),
+    supportsSessions: capabilityEnabled(manifest, 'sessions'),
+    supportsSkills: manifest.resourceTypes?.skills !== false,
+    supportsCommands: manifest.resourceTypes?.commands !== false,
+    supportsPlugins: manifest.resourceTypes?.plugins !== false,
+    supportsAgents: manifest.resourceTypes?.agents !== false
+  }));
 
-function normalizeCustomCliPlatform(input = {}) {
-  const rawKey = normalizePlatformKey(input.key);
-  const key = rawKey
-    .replace(/[^a-z0-9_-]/g, '-')
-    .replace(/-+/g, '-')
-    .replace(/^-|-$/g, '');
+function normalizePlatformKey(value = '') {
+  return String(value || '').trim().toLowerCase();
+}
 
-  if (!key || getPlatformDefinition(key)) {
-    return null;
+function normalizeAllowedPlatformKeys(allowedKeys) {
+  if (!allowedKeys || typeof allowedKeys[Symbol.iterator] !== 'function') {
+    return new Set();
   }
 
-  const name = String(input.name || input.title || key).trim() || key;
-  const command = String(input.command || key).trim() || key;
-  return {
-    key,
-    name,
-    title: String(input.title || name).trim() || name,
-    command,
-    configDir: String(input.configDir || '').trim(),
-    icon: String(input.icon || '').trim(),
-    color: String(input.color || '').trim(),
-    enabled: input.enabled !== false,
-    custom: true,
-    supportsManagedChannels: false,
-    supportsManagedConfig: false,
-    supportsProxy: false,
-    supportsProjects: false,
-    supportsSessions: false,
-    supportsSkills: false,
-    supportsCommands: false,
-    supportsPlugins: false,
-    supportsAgents: false
-  };
+  const normalized = new Set();
+  for (const value of allowedKeys) {
+    const key = normalizePlatformKey(value);
+    if (key) {
+      normalized.add(key);
+    }
+  }
+  return normalized;
 }
 
-function normalizeCustomCliPlatforms(input = []) {
+function normalizeEnabledCliPlatforms(input, allowedKeys, fallback = DEFAULT_ENABLED_CLI_PLATFORMS) {
+  const allowed = normalizeAllowedPlatformKeys(allowedKeys);
+  const values = Array.isArray(input) ? input : fallback;
   const result = [];
   const seen = new Set();
 
-  if (!Array.isArray(input)) {
+  if (!Array.isArray(values)) {
     return result;
   }
 
-  input.forEach((item) => {
-    const normalized = normalizeCustomCliPlatform(item);
-    if (!normalized || seen.has(normalized.key)) {
-      return;
+  for (const value of values) {
+    const key = normalizePlatformKey(value);
+    if (!key || seen.has(key) || !allowed.has(key)) {
+      continue;
     }
-    seen.add(normalized.key);
-    result.push(normalized);
-  });
-
+    seen.add(key);
+    result.push(key);
+  }
   return result;
 }
 
-function normalizeHomeCliColumns(input = [], customCliPlatforms = []) {
-  const customKeys = new Set(
-    normalizeCustomCliPlatforms(customCliPlatforms)
-      .filter(platform => platform.enabled !== false)
-      .map(platform => platform.key)
-  );
-  const builtInKeys = new Set(getBuiltInPlatformKeys());
-  const allowed = key => builtInKeys.has(key) || customKeys.has(key);
-  const result = [];
+function migrateLegacyCliConfig(config = {}) {
+  const {
+    enabledCliPlatforms,
+    homeCliColumns,
+    dashboardChannelOrder,
+    allowedKeys
+  } = config;
+  const hasExplicitSelection = Object.prototype.hasOwnProperty.call(config, 'enabledCliPlatforms');
 
-  if (Array.isArray(input)) {
-    input.forEach((value) => {
-      const key = normalizePlatformKey(value);
-      if (!key || result.includes(key) || !allowed(key)) {
-        return;
-      }
-      result.push(key);
-    });
+  if (hasExplicitSelection) {
+    return normalizeEnabledCliPlatforms(enabledCliPlatforms, allowedKeys, DEFAULT_ENABLED_CLI_PLATFORMS);
   }
 
-  DEFAULT_HOME_CLI_COLUMNS.forEach((key) => {
-    if (result.length >= MAX_HOME_CLI_COLUMNS) {
-      return;
-    }
-    if (!result.includes(key)) {
+  const allowed = normalizeAllowedPlatformKeys(allowedKeys);
+  const legacyInput = Array.isArray(homeCliColumns)
+    ? homeCliColumns
+    : dashboardChannelOrder;
+  const normalizedLegacyInput = Array.isArray(legacyInput)
+    ? legacyInput.map(normalizePlatformKey)
+    : [];
+  const normalizedLegacy = normalizeEnabledCliPlatforms(legacyInput, allowedKeys, []);
+  const isExactOldDefault = normalizedLegacyInput.length === 4 &&
+    normalizedLegacyInput.every((key, index) => key === ['claude', 'codex', 'gemini', 'opencode'][index]);
+
+  if (isExactOldDefault) {
+    return normalizeEnabledCliPlatforms(DEFAULT_ENABLED_CLI_PLATFORMS, allowedKeys, DEFAULT_ENABLED_CLI_PLATFORMS);
+  }
+
+  const result = [...normalizedLegacy];
+  for (const key of DEFAULT_ENABLED_CLI_PLATFORMS) {
+    if (allowed.has(key) && !result.includes(key)) {
       result.push(key);
     }
-  });
+  }
+
+  return result.length > 0
+    ? result
+    : normalizeEnabledCliPlatforms(DEFAULT_ENABLED_CLI_PLATFORMS, allowedKeys, DEFAULT_ENABLED_CLI_PLATFORMS);
+}
+
+function getBuiltInPlatformKeys() {
+  return BUILT_IN_CLI_PLATFORMS.map(platform => platform.key);
+}
 
-  return result.slice(0, MAX_HOME_CLI_COLUMNS);
+function getPlatformDefinition(key) {
+  const normalizedKey = normalizePlatformKey(key);
+  return BUILT_IN_CLI_PLATFORMS.find(platform => platform.key === normalizedKey) || null;
 }
 
 module.exports = {
   BUILT_IN_CLI_PLATFORMS,
-  DEFAULT_HOME_CLI_COLUMNS,
-  MAX_HOME_CLI_COLUMNS,
+  DEFAULT_ENABLED_CLI_PLATFORMS,
   getBuiltInPlatformKeys,
   getPlatformDefinition,
   normalizePlatformKey,
-  normalizeCustomCliPlatform,
-  normalizeCustomCliPlatforms,
-  normalizeHomeCliColumns
+  normalizeEnabledCliPlatforms,
+  migrateLegacyCliConfig
 };