coding-tool-x 3.8.4 → 3.8.6

package/src/shared/channel-driver.js

@@ -0,0 +1,161 @@
+'use strict';
+
+const { ok, unsupported, invalid, failed } = require('./driver-result');
+
+const SECRET_KEYS = new Set(['key', 'token', 'secret', 'password', 'accessToken', 'refreshToken', 'idToken', 'credential', 'raw']);
+const COMMON_KEYS = new Set([
+  'id', 'name', 'baseUrl', 'enabled', 'weight', 'maxConcurrency',
+  'routingGroup', 'providerKey', 'providerApi', 'model', 'wireApi',
+  'gatewaySourceType', 'websiteUrl', 'createdAt', 'updatedAt',
+  'authMode', 'authRef', 'authSource', 'authStatus', 'oauthProviderId', 'apiKey',
+  'transport', 'providerConfig'
+]);
+
+function isSecretKey(key) {
+  return SECRET_KEYS.has(key) || /token|secret|password|credential/i.test(key);
+}
+
+function sanitizeValue(value) {
+  if (Array.isArray(value)) return value.map(sanitizeValue);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(Object.entries(value)
+    .filter(([key]) => !isSecretKey(key))
+    .map(([key, child]) => [key, sanitizeValue(child)]));
+}
+
+function sanitizeChannel(channel) {
+  if (!channel || typeof channel !== 'object' || Array.isArray(channel)) return channel;
+  const common = {};
+  const extra = {};
+  for (const [key, value] of Object.entries(channel)) {
+    if (isSecretKey(key)) continue;
+    if (COMMON_KEYS.has(key)) common[key] = sanitizeValue(value);
+    else extra[key] = sanitizeValue(value);
+  }
+  if (Object.keys(extra).length) common.extra = extra;
+  if (common.authRef) {
+    const ref = common.authRef;
+    common.authRef = Object.fromEntries(['credentialId', 'providerId', 'accountId', 'identityKey', 'accountEmail']
+      .map(key => [key, String(ref[key] || '')]));
+  }
+  return common;
+}
+
+function sanitizeChannels(value) {
+  const channels = Array.isArray(value) ? value : value?.channels;
+  return { channels: Array.isArray(channels) ? channels.map(sanitizeChannel) : [] };
+}
+
+function isInvalidError(error) {
+  return /invalid|required|not found|must be|unknown channel/i.test(String(error?.message || error));
+}
+
+function createChannelDriver({
+  platform,
+  servicePath,
+  localServicePath,
+  createArgs,
+  listMethod = 'getChannels',
+  syncMethod,
+  requireImpl,
+  capability = 'channels',
+  cliMetadata = {},
+  formatCliChannelDetails,
+  dashboardChannelShape = 'object',
+  modelListType,
+  ...context
+} = {}) {
+  let service;
+  const loadService = () => {
+    if (!service) {
+      service = requireImpl ? requireImpl(servicePath) : require(localServicePath);
+      if (typeof service?.configure === 'function') {
+        service.configure({ ...context, platform, capability });
+      }
+    }
+    return service;
+  };
+
+  const call = (operation, method, args = [], transform = value => value) => {
+    const target = loadService();
+    if (!target || typeof target[method] !== 'function') {
+      return unsupported(platform, capability, operation);
+    }
+    const wrap = value => {
+      if (value && typeof value === 'object' && typeof value.status === 'string') return value;
+      return ok(platform, capability, operation, transform(value));
+    };
+    try {
+      const value = target[method](...args);
+      if (value && typeof value.then === 'function') {
+        return value.then(wrap)
+          .catch(error => isInvalidError(error)
+            ? invalid(platform, capability, operation, error)
+            : failed(platform, capability, operation, error));
+      }
+      return wrap(value);
+    } catch (error) {
+      return isInvalidError(error)
+        ? invalid(platform, capability, operation, error)
+        : failed(platform, capability, operation, error);
+    }
+  };
+  const driver = { platform, capability };
+  driver.getCliMetadata = () => ({ ...cliMetadata });
+  driver.formatCliChannelDetails = typeof formatCliChannelDetails === 'function'
+    ? channel => formatCliChannelDetails(channel)
+    : () => [];
+  driver.normalizeDashboardChannels = value => {
+    if (value && typeof value === 'object' && typeof value.status === 'string') return value;
+    const channels = Array.isArray(value) ? value : value?.channels;
+    if (dashboardChannelShape === 'array') {
+      return Array.isArray(channels) ? channels : [];
+    }
+    if (Array.isArray(channels)) return { channels };
+    return value == null ? { channels: [] } : value;
+  };
+  Object.defineProperty(driver, '_service', { value: loadService, enumerable: false });
+  driver.listModels = async (channel, options = {}) => {
+    if (!modelListType) {
+      return unsupported(platform, capability, 'listModels');
+    }
+    try {
+      const { fetchModelsFromProvider } = require('../server/services/model-detector');
+      const data = await fetchModelsFromProvider(channel, modelListType, options);
+      return ok(platform, capability, 'listModels', data);
+    } catch (error) {
+      return failed(platform, capability, 'listModels', error);
+    }
+  };
+  driver.list = (...args) => call('list', listMethod, args, sanitizeChannels);
+  driver.getEnabled = (...args) => call('getEnabled', 'getEnabledChannels', args, channels => sanitizeChannels(channels).channels);
+  driver.create = (input, ...rest) => {
+    if (input == null && rest.length === 0) return invalid(platform, capability, 'create', new Error('Channel input is required'));
+    const args = createArgs ? createArgs(input, rest) : [input, ...rest];
+    return call('create', 'createChannel', args, sanitizeChannel);
+  };
+  driver.update = (id, patch) => {
+    if (!id || !patch || typeof patch !== 'object') return invalid(platform, capability, 'update', new Error('Channel id and patch are required'));
+    return call('update', 'updateChannel', [id, patch], sanitizeChannel);
+  };
+  driver.remove = id => {
+    if (!id) return invalid(platform, capability, 'remove', new Error('Channel id is required'));
+    return call('remove', 'deleteChannel', [id]);
+  };
+  driver.syncCurrent = (...args) => syncMethod
+    ? call('syncCurrent', syncMethod, args)
+    : unsupported(platform, capability, 'syncCurrent');
+  driver.applyNativeConfig = id => id
+    ? call('applyNativeConfig', 'applyChannelToSettings', [id], sanitizeChannel)
+    : invalid(platform, capability, 'applyNativeConfig', new Error('Channel id is required'));
+  driver.getEffectiveApiKey = channel => call('getEffectiveApiKey', 'getEffectiveApiKey', [channel]);
+  driver.disableAll = (...args) => call('disableAll', 'disableAllChannels', args);
+  driver.markRecentlyUsed = id => id
+    ? call('markRecentlyUsed', 'markChannelAsRecentlyUsed', [id], sanitizeChannel)
+    : invalid(platform, capability, 'markRecentlyUsed', new Error('Channel id is required'));
+  driver.saveOrder = order => call('saveOrder', 'saveChannelOrder', [order]);
+
+  return driver;
+}
+
+module.exports = { createChannelDriver, sanitizeChannel, sanitizeChannels };

package/src/shared/driver-factories/api.js

@@ -0,0 +1,180 @@
+'use strict';
+
+function resultFor(context, status, data, error, cause) {
+  const result = {
+    status,
+    platform: context.platform,
+    capability: context.route?.capability || 'api',
+    operation: context.route?.operation || context.operation
+  };
+  if (status === 'ok') result.data = data;
+  if (error) result.error = typeof error === 'string' ? error : error.message || String(error);
+  if (cause) Object.defineProperty(result, 'cause', { value: cause, enumerable: false });
+  return result;
+}
+
+function optionsFor(context) {
+  const force = context.query?.fresh === '1' || context.query?.fresh === 'true';
+  return {
+    ...(context.query || {}),
+    config: context.config,
+    force
+  };
+}
+
+function argsFor(capability, operation, context) {
+  const params = context.params || {};
+  const options = optionsFor(context);
+  if (options.force && (capability === 'projects' || capability === 'sessions')) {
+    options.consistency = 'complete';
+  }
+  if (capability === 'projects') {
+    if (operation === 'listProjects') return [options];
+    if (operation === 'deleteProject') return [params.projectName, options];
+    if (operation === 'saveProjectOrder') return [context.body?.order || context.body, options];
+    if (operation === 'createProject') return [context.body || {}, options];
+  }
+  if (capability === 'sessions') {
+    const projectName = params.projectName;
+    const keyword = context.query?.keyword || context.query?.q || context.query?.query || '';
+    if (operation === 'recent') return [Number(context.query?.limit) || undefined, options];
+    if (operation === 'searchAcrossProjects') {
+      const numericOption = context.platform === 'gemini'
+        ? Number(context.query?.context) || 35
+        : Number(context.query?.limit) || undefined;
+      return [keyword, numericOption, options];
+    }
+    if (operation === 'listSessions') return [projectName, options];
+    if (operation === 'search') {
+      return [projectName, keyword, Number(context.query?.context) || 15, options];
+    }
+    if (['status', 'outline', 'messages'].includes(operation)) return [params.sessionId, options];
+    if (operation === 'delete') {
+      return context.platform === 'claude'
+        ? [projectName, params.sessionId, options]
+        : [params.sessionId, options];
+    }
+    if (operation === 'fork') {
+      const mutationOptions = { ...options, ...(context.body || {}) };
+      return context.platform === 'claude'
+        ? [projectName, params.sessionId, mutationOptions]
+        : [params.sessionId, mutationOptions];
+    }
+    if (operation === 'launch') return [params.sessionId, { ...options, ...(context.body || {}) }];
+    if (operation === 'batchDelete') return [projectName, context.body?.sessionIds || context.body?.ids || [], options];
+    if (operation === 'createSession') return [projectName, context.body || {}, options];
+    if (operation === 'saveSessionOrder') return [projectName, context.body?.order || context.body, options];
+  }
+  if (capability === 'channels') {
+    if (operation === 'list' || operation === 'enabled' || operation === 'current' || operation === 'bestForRestore') return [options];
+    if (operation === 'create') return [context.body || {}];
+    if (operation === 'update') return [params.channelId, context.body || {}];
+    if (operation === 'remove') return [params.channelId];
+    if (operation === 'models') return [params.channelId, options];
+    if (operation === 'applyToSettings') return [params.channelId];
+    return [context.body || options];
+  }
+  if (capability === 'proxy') return [options];
+  if (capability === 'statistics') {
+    if (operation === 'daily') return [params.date || context.query?.date, options];
+    return [options];
+  }
+  return [context];
+}
+const TARGET_OPERATIONS = Object.freeze({
+  channels: Object.freeze({
+    enabled: 'getEnabled',
+    current: 'getCurrentChannel',
+    bestForRestore: 'getBestChannelForRestore',
+    sync: 'syncCurrent',
+    order: 'saveOrder',
+    applyToSettings: 'applyNativeConfig'
+  }),
+  statistics: Object.freeze({
+    summary: 'getStatistics',
+    today: 'getTodayStatistics',
+    daily: 'getDailyStatistics'
+  })
+});
+
+function targetOperation(capability, operation) {
+  return TARGET_OPERATIONS[capability]?.[operation] || operation;
+}
+
+function createApiOperationsDriver({ platform, runtime, manifest, config, sessionHistoryIndex, operationHandlers = {} } = {}) {
+  const driver = { platform, capability: 'api' };
+  const operations = new Set();
+  for (const route of manifest?.api?.routes || []) operations.add(route.operation);
+  const routeByOperation = new Map((manifest?.api?.routes || []).map(route => [route.operation, route]));
+
+  const decorateReadModel = async (capability, operation, value) => {
+    if (capability !== 'projects' && capability !== 'sessions') return value;
+    const isProjectList = capability === 'projects' && operation === 'listProjects';
+    const isSessionList = capability === 'sessions' && ['listSessions', 'recent', 'search', 'searchAcrossProjects'].includes(operation);
+    if (!isProjectList && !isSessionList) return value;
+    const payload = Array.isArray(value)
+      ? (isProjectList ? { projects: value } : { sessions: value })
+      : { ...(value && typeof value === 'object' ? value : {}) };
+    if (isProjectList && !Array.isArray(payload.projects)) payload.projects = [];
+    if (isSessionList && !Array.isArray(payload.sessions)) payload.sessions = [];
+    if (!payload.meta && typeof sessionHistoryIndex?.getSourceIndexMeta === 'function') {
+      payload.meta = sessionHistoryIndex.getSourceIndexMeta(platform);
+    }
+    if (isProjectList && !Object.prototype.hasOwnProperty.call(payload, 'currentProject')) {
+      payload.currentProject = platform === 'claude' ? config?.currentProject || null : null;
+    }
+    return payload;
+  };
+
+  for (const operation of operations) {
+    driver[operation] = async context => {
+      const route = context.route || routeByOperation.get(operation);
+      const requestContext = route && !context.route ? { ...context, route } : context;
+      const capability = route?.capability;
+      try {
+        const handler = operationHandlers[operation];
+        if (typeof handler === 'function') {
+          return resultFor(requestContext, 'ok', await handler(requestContext, { config, runtime, sessionHistoryIndex }));
+        }
+        if (capability === 'sessions' && sessionHistoryIndex && platform !== 'opencode') {
+          const index = sessionHistoryIndex;
+          const sessionId = requestContext.params?.sessionId;
+          const indexCall = operation === 'status'
+            ? index.getSessionStatus?.(platform, sessionId, { consistency: 'stale-ok' })
+            : operation === 'outline'
+              ? index.getSessionOutline?.(platform, sessionId, { consistency: 'stale-ok' })
+              : operation === 'messages'
+                ? index.getMessagePage?.(platform, sessionId, {
+                  page: Number(requestContext.query?.page) || 1,
+                  limit: Number(requestContext.query?.limit) || 50,
+                  order: requestContext.query?.order,
+                  consistency: 'stale-ok'
+                })
+                : null;
+          if (indexCall) return resultFor(requestContext, 'ok', await indexCall);
+        }
+        const target = runtime?.getDriver?.(platform, capability, {
+          config: requestContext.config ?? config,
+          manifest,
+          route
+        });
+        const operationName = targetOperation(capability, operation);
+        if (!target || typeof target[operationName] !== 'function') {
+          return resultFor(requestContext, 'unsupported');
+        }
+        const value = await target[operationName](...argsFor(capability, operation, requestContext));
+        if (value && typeof value === 'object' && typeof value.status === 'string') {
+          if (value.status !== 'ok') return resultFor(requestContext, value.status, undefined, value.error, value.cause);
+          return resultFor(requestContext, 'ok', await decorateReadModel(capability, operation, value.data));
+        }
+        return resultFor(requestContext, 'ok', await decorateReadModel(capability, operation, value));
+      } catch (error) {
+        return resultFor(requestContext, 'failed', undefined, error, error);
+      }
+    };
+  }
+
+  return driver;
+}
+
+module.exports = { createApiOperationsDriver };

package/src/shared/driver-factories/mcp.js

@@ -0,0 +1,244 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const toml = require('@iarna/toml');
+const tomlStringify = require('@iarna/toml').stringify;
+const { ok, failed } = require('../driver-result');
+const { extractServerSpec, convertToCodexFormat, convertFromCodexFormat, convertToOmpMcpFormat, convertFromOmpMcpFormat, convertToOpenCodeFormat, convertFromOpenCodeFormat } = require('../mcp-format');
+const { redactSecrets, validateMcpId } = require('../project-config');
+
+const SCHEMA_URL = 'https://raw.githubusercontent.com/can1357/oh-my-omp/main/packages/coding-agent/src/config/mcp-schema.json';
+
+function stripJsonComments(input) {
+  let output = '';
+  let inString = false;
+  let escaped = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index];
+    const next = input[index + 1];
+    if (inLineComment) {
+      if (char === '\n') { inLineComment = false; output += char; }
+      else output += ' ';
+      continue;
+    }
+    if (inBlockComment) {
+      if (char === '*' && next === '/') { inBlockComment = false; output += '  '; index += 1; }
+      else output += char === '\n' ? '\n' : ' ';
+      continue;
+    }
+    if (inString) {
+      output += char;
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === '"') inString = false;
+      continue;
+    }
+    if (char === '"') { inString = true; output += char; continue; }
+    if (char === '/' && next === '/') { inLineComment = true; output += '  '; index += 1; continue; }
+    if (char === '/' && next === '*') { inBlockComment = true; output += '  '; index += 1; continue; }
+    output += char;
+  }
+  return output.replace(/,\s*([}\]])/g, '$1');
+}
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function readJson(filePath, fallback = {}) {
+  if (!fs.existsSync(filePath)) return fallback;
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return content.trim() ? JSON.parse(content) : fallback;
+  } catch (_) {
+    return fallback;
+  }
+}
+
+function writeJson(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+  fs.writeFileSync(tempPath, JSON.stringify(value, null, 2), 'utf8');
+  fs.renameSync(tempPath, filePath);
+}
+
+function readToml(filePath) {
+  if (!fs.existsSync(filePath)) return {};
+  return toml.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function writeToml(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+  fs.writeFileSync(tempPath, tomlStringify(value), 'utf8');
+  fs.renameSync(tempPath, filePath);
+}
+
+function sanitizeSpec(spec) {
+  return redactSecrets(extractServerSpec(spec));
+}
+
+function normalizeSpec(spec) {
+  return { ...spec, type: spec?.type || 'stdio' };
+}
+
+function createMcpDriver({ platform, ...context } = {}) {
+  const { PATHS, NATIVE_PATHS } = require('../../config/paths');
+  const { resolvePreferredHomeDir } = require('../../utils/home-dir');
+  const pathContext = context.pathContext || {};
+  const home = pathContext.home || resolvePreferredHomeDir(process.platform, process.env, os.homedir());
+  const configuredNative = pathContext.native || {};
+  const native = configuredNative[platform]
+    ? configuredNative[platform]
+    : configuredNative;
+  const legacyNative = NATIVE_PATHS || {};
+  const paths = {
+    claude: native.mcp || legacyNative.claude?.mcp || path.join(home, '.claude.json'),
+    codex: native.mcp || legacyNative.codex?.config || (native.config ? native.config : undefined),
+    gemini: native.mcp || legacyNative.gemini?.settings || (native.settings ? native.settings : path.join(home, '.gemini', 'settings.json')),
+    opencode: native.mcp || legacyNative.opencode?.config || native.config,
+    omp: native.mcp || legacyNative.omp?.mcp || path.join(native.dir || path.join(home, '.omp', 'agent'), 'mcp.json')
+  };
+
+  if (!paths[platform]) throw new Error(`MCP path is not configured for ${platform}`);
+
+  function selectOpenCodePath() {
+    const candidates = [
+      path.join(paths.opencode, 'opencode.jsonc'),
+      path.join(paths.opencode, 'opencode.json'),
+      path.join(paths.opencode, 'config.json')
+    ];
+    return candidates.find(filePath => fs.existsSync(filePath)) || candidates[1];
+  }
+
+  function readOpenCode() {
+    const filePath = selectOpenCodePath();
+    if (!fs.existsSync(filePath)) return { path: filePath, config: {} };
+    try {
+      const raw = fs.readFileSync(filePath, 'utf8');
+      return { path: filePath, config: JSON.parse(filePath.endsWith('.jsonc') ? stripJsonComments(raw) : raw) };
+    } catch (_) {
+      return { path: filePath, config: {} };
+    }
+  }
+
+  function read() {
+    if (platform === 'claude' || platform === 'gemini' || platform === 'omp') return readJson(paths[platform], platform === 'omp' ? { mcpServers: {} } : {});
+    if (platform === 'codex') return readToml(paths.codex);
+    return readOpenCode().config;
+  }
+
+  function write(config) {
+    if (!config || typeof config !== 'object' || Array.isArray(config)) throw new Error('MCP 平台配置必须是对象');
+    if (platform === 'claude' || platform === 'gemini' || platform === 'omp') writeJson(paths[platform], config);
+    else if (platform === 'codex') writeToml(paths.codex, config);
+    else writeJson(selectOpenCodePath(), config);
+    return config;
+  }
+
+  function serverMap(config) {
+    const key = platform === 'codex' ? 'mcp_servers' : platform === 'opencode' ? 'mcp' : 'mcpServers';
+    if (!config[key] || typeof config[key] !== 'object' || Array.isArray(config[key])) config[key] = {};
+    return config[key];
+  }
+
+  function nativeSpec(spec) {
+    if (platform === 'codex') return convertToCodexFormat(spec);
+    if (platform === 'opencode') return convertToOpenCodeFormat(spec);
+    if (platform === 'omp') return convertToOmpMcpFormat(spec);
+    return spec;
+  }
+
+  function internalSpec(spec) {
+    if (platform === 'codex') return convertFromCodexFormat(spec);
+    if (platform === 'opencode') return convertFromOpenCodeFormat(spec);
+    if (platform === 'omp') return convertFromOmpMcpFormat(spec);
+    return normalizeSpec(spec);
+  }
+
+  function sync(server) {
+    if (!server?.id) throw new Error('MCP 服务器 ID 不能为空');
+    if (platform === 'codex' && !fs.existsSync(paths.codex)) {
+      throw new Error('Codex config.toml not found. Please run Codex CLI at least once before syncing MCP servers.');
+    }
+    if (platform === 'omp') validateMcpId(server.id);
+    const config = read();
+    const map = serverMap(config);
+    map[server.id] = nativeSpec(extractServerSpec(server.server));
+    if (platform === 'omp' && !config.mcpServers) config.mcpServers = map;
+    write(config);
+    return config;
+  }
+
+  function remove(serverId) {
+    if (!serverId || !String(serverId).trim()) throw new Error('MCP 服务器 ID 不能为空');
+    const config = read();
+    const map = serverMap(config);
+    if (Object.prototype.hasOwnProperty.call(map, serverId)) {
+      delete map[serverId];
+      if (platform === 'codex' && Object.keys(map).length === 0) delete config.mcp_servers;
+      write(config);
+    }
+    return config;
+  }
+
+  function importServers(servers) {
+    const config = read();
+    const map = serverMap(config);
+    let count = 0;
+    for (const [id, spec] of Object.entries(map)) {
+      if (!spec || typeof spec !== 'object' || Array.isArray(spec)) continue;
+      if (servers[id]) {
+        servers[id].apps = { ...(servers[id].apps || {}), [platform]: true };
+        count += 1;
+        continue;
+      }
+      const now = Date.now();
+      servers[id] = { id, name: id, server: internalSpec(spec), apps: { [platform]: true }, createdAt: now, updatedAt: now };
+      count += 1;
+    }
+    return count;
+  }
+
+  function exportServers(servers) {
+    const map = {};
+    for (const [id, server] of Object.entries(servers || {})) {
+      if (server.apps?.[platform]) map[id] = nativeSpec(sanitizeSpec(server.server));
+    }
+    if (platform === 'omp') return { format: 'omp', content: JSON.stringify({ $schema: SCHEMA_URL, mcpServers: map }, null, 2), contentType: 'application/json', filename: 'omp-mcp-config.json' };
+    if (platform === 'opencode') return { format: 'opencode', content: JSON.stringify({ mcp: map }, null, 2), contentType: 'application/json', filename: 'opencode-mcp-config.json' };
+    if (platform === 'codex') return { format: 'codex', content: tomlStringify({ mcp_servers: map }), contentType: 'application/toml', filename: 'codex-mcp-config.toml' };
+    return { format: platform, content: JSON.stringify({ mcpServers: map }, null, 2), contentType: 'application/json', filename: `${platform}-mcp-config.json` };
+  }
+
+  const invoke = (operation, args) => {
+    try {
+      const methods = { read, write, remove, sync, import: importServers, export: exportServers, normalize: internalSpec, entries: () => Object.fromEntries(Object.entries(serverMap(read())).map(([id, spec]) => [id, internalSpec(spec)])) };
+      const value = methods[operation](...args);
+      const wrap = data => ok(platform, 'mcp', operation, data);
+      return value && typeof value.then === 'function' ? value.then(wrap).catch(error => failed(platform, 'mcp', operation, error)) : wrap(value);
+    } catch (error) {
+      return failed(platform, 'mcp', operation, error);
+    }
+  };
+
+  return {
+    platform,
+    capability: 'mcp',
+    ...context,
+    read: (...args) => invoke('read', args),
+    write: (...args) => invoke('write', args),
+    remove: (...args) => invoke('remove', args),
+    sync: (...args) => invoke('sync', args),
+    import: (...args) => invoke('import', args),
+    export: (...args) => invoke('export', args),
+    normalize: (...args) => invoke('normalize', args),
+    entries: (...args) => invoke('entries', args)
+  };
+}
+
+module.exports = { createMcpDriver, stripJsonComments };