coding-tool-x 3.8.4 → 3.8.6

package/src/server/api/convert.js

@@ -1,53 +1,30 @@
 const express = require('express');
 const router = express.Router();
-const { convertSession, previewConversion } = require('../services/session-converter');
-const {
-  SUPPORTED_SOURCE_TYPES,
-  SUPPORTED_TARGET_APIS,
-  convertToOpenCodePayload,
-  convertClaudeToOpenCodePayload,
-  convertCodexToOpenCodePayload,
-  convertGeminiToOpenCodePayload,
-  normalizeSourceType
-} = require('../services/opencode-gateway-converter');
+const { getPlatformCatalog } = require('../services/platform-catalog');
 
 /**
  * 获取支持的格式列表
  * GET /api/convert/formats
  */
 router.get('/formats', (req, res) => {
+  const driver = getPlatformCatalog().driver('opencode', 'conversion');
+  const formats = driver?.formats?.() || driver?.getFormats?.();
+  if (!formats) {
+    return res.status(404).json({ success: false, error: 'Conversion is not supported' });
+  }
+  const sourceTypes = formats.sourceTypes || [];
   res.json({
-    formats: [
-      {
-        id: 'claude',
-        name: 'Claude Code',
-        description: 'Anthropic Claude Code CLI session format',
-        extension: '.jsonl',
-        icon: 'claude'
-      },
-      {
-        id: 'codex',
-        name: 'OpenAI Codex',
-        description: 'OpenAI Codex CLI session format',
-        extension: '.jsonl',
-        icon: 'codex'
-      },
-      {
-        id: 'gemini',
-        name: 'Google Gemini',
-        description: 'Google Gemini CLI session format',
-        extension: '.json',
-        icon: 'gemini'
-      }
-    ],
-    conversions: [
-      { from: 'claude', to: 'codex' },
-      { from: 'claude', to: 'gemini' },
-      { from: 'codex', to: 'claude' },
-      { from: 'codex', to: 'gemini' },
-      { from: 'gemini', to: 'claude' },
-      { from: 'gemini', to: 'codex' }
-    ]
+    formats: sourceTypes.map(type => ({
+      id: type,
+      name: (formats.formats || []).find(item => item.id === type)?.name
+        || String(type).replace(/[-_]/g, ' ').replace(/\b\w/g, char => char.toUpperCase()),
+      description: `${type} session format`,
+      extension: '.jsonl',
+      icon: type
+    })),
+    conversions: sourceTypes.flatMap(sourceType => sourceTypes
+      .filter(targetType => targetType !== sourceType)
+      .map(targetType => ({ from: sourceType, to: targetType })))
   });
 });
 
@@ -56,42 +33,47 @@ router.get('/formats', (req, res) => {
  * GET /api/convert/opencode/formats
  */
 router.get('/opencode/formats', (req, res) => {
+  const driver = getConversionDriver();
+  const formats = driver?.formats?.() || driver?.getFormats?.();
+  if (!formats) {
+    return res.status(404).json({ success: false, error: 'Conversion is not supported' });
+  }
+  const sourceTypes = formats.sourceTypes || [];
   res.json({
-    sourceTypes: SUPPORTED_SOURCE_TYPES.map(type => ({
+    sourceTypes: sourceTypes.map(type => ({
       id: type,
-      name: type === 'claude'
-        ? 'Claude Code'
-        : type === 'codex'
-          ? 'Codex'
-          : 'Gemini'
+      name: (formats.formats || []).find(item => item.id === type)?.name
+        || String(type).replace(/[-_]/g, ' ').replace(/\b\w/g, char => char.toUpperCase())
     })),
     target: 'opencode',
-    targetApis: SUPPORTED_TARGET_APIS,
-    defaultTargetApi: 'responses',
-    endpoints: {
-      responses: '/v1/responses',
-      'chat.completions': '/v1/chat/completions'
-    },
-    sourceEndpoints: {
-      claude: '/api/convert/opencode/claude',
-      codex: '/api/convert/opencode/codex',
-      gemini: '/api/convert/opencode/gemini'
-    }
+    targetApis: formats.targetApis || [],
+    defaultTargetApi: formats.defaultTargetApi,
+    endpoints: formats.endpoints || {},
+    sourceEndpoints: Object.fromEntries(sourceTypes.map(type => [type, `/api/convert/opencode/${type}`]))
   });
 });
 
-function handleOpenCodeConvert(req, res, sourceType, converter) {
+function getConversionDriver() {
+  return getPlatformCatalog().driver('opencode', 'conversion');
+}
+
+function handleOpenCodeConvert(req, res, sourceType) {
   try {
     const { payload, options = {} } = req.body || {};
+    const driver = getConversionDriver();
 
+    if (!driver) {
+      return res.status(404).json({ success: false, error: 'Conversion is not supported' });
+    }
     if (!payload) {
       return res.status(400).json({
         success: false,
         error: 'Missing required parameters: payload'
       });
     }
-
-    const result = converter({ payload, options });
+    const result = driver.convertSource
+      ? driver.convertSource(sourceType, payload, options)
+      : driver.convert({ sourceType, payload, options });
     return res.json({
       success: true,
       ...result
@@ -105,31 +87,8 @@ function handleOpenCodeConvert(req, res, sourceType, converter) {
   }
 }
 
-/**
- * Claude Code -> OpenCode
- * POST /api/convert/opencode/claude
- * Body: { payload, options? }
- */
-router.post('/opencode/claude', (req, res) => {
-  return handleOpenCodeConvert(req, res, 'claude', convertClaudeToOpenCodePayload);
-});
-
-/**
- * Codex -> OpenCode
- * POST /api/convert/opencode/codex
- * Body: { payload, options? }
- */
-router.post('/opencode/codex', (req, res) => {
-  return handleOpenCodeConvert(req, res, 'codex', convertCodexToOpenCodePayload);
-});
-
-/**
- * Gemini -> OpenCode
- * POST /api/convert/opencode/gemini
- * Body: { payload, options? }
- */
-router.post('/opencode/gemini', (req, res) => {
-  return handleOpenCodeConvert(req, res, 'gemini', convertGeminiToOpenCodePayload);
+router.post('/opencode/:sourceType', (req, res) => {
+  return handleOpenCodeConvert(req, res, req.params.sourceType);
 });
 
 /**
@@ -140,31 +99,29 @@ router.post('/opencode/gemini', (req, res) => {
 router.post('/opencode', (req, res) => {
   try {
     const { sourceType, payload, options = {} } = req.body || {};
+    const driver = getConversionDriver();
+    const sourceTypes = driver?.formats?.().sourceTypes || driver?.getFormats?.().sourceTypes || [];
+    const normalized = driver?.normalizeSourceType?.(sourceType) || sourceType;
 
+    if (!driver) {
+      return res.status(404).json({ success: false, error: 'Conversion is not supported' });
+    }
     if (!sourceType || !payload) {
       return res.status(400).json({
         success: false,
         error: 'Missing required parameters: sourceType, payload'
       });
     }
-
-    const normalized = normalizeSourceType(sourceType);
-    if (!SUPPORTED_SOURCE_TYPES.includes(normalized)) {
+    if (!sourceTypes.includes(normalized)) {
       return res.status(400).json({
         success: false,
-        error: `Invalid sourceType: ${sourceType}. Must be one of: ${SUPPORTED_SOURCE_TYPES.join(', ')}`
+        error: `Invalid sourceType: ${sourceType}. Must be one of: ${sourceTypes.join(', ')}`
       });
     }
 
-    const result = convertToOpenCodePayload({
-      sourceType: normalized,
-      payload,
-      options
-    });
-
     return res.json({
       success: true,
-      ...result
+      ...driver.convert({ sourceType: normalized, payload, options })
     });
   } catch (error) {
     console.error('[Convert API] OpenCode gateway convert error:', error);
@@ -175,86 +132,5 @@ router.post('/opencode', (req, res) => {
   }
 });
 
-/**
- * 预览转换结果
- * POST /api/convert/preview
- * Body: { sourceType, sessionId }
- */
-router.post('/preview', async (req, res) => {
-  try {
-    const { sourceType, sessionId } = req.body;
-
-    if (!sourceType || !sessionId) {
-      return res.status(400).json({
-        success: false,
-        error: 'Missing required parameters: sourceType, sessionId'
-      });
-    }
-
-    const preview = await previewConversion(sourceType, sessionId);
-
-    res.json({
-      success: true,
-      preview
-    });
-  } catch (error) {
-    console.error('[Convert API] Preview error:', error);
-    res.status(500).json({
-      success: false,
-      error: error.message
-    });
-  }
-});
-
-/**
- * 执行会话转换
- * POST /api/convert
- * Body: { sourceType, targetType, sessionId, options }
- */
-router.post('/', async (req, res) => {
-  try {
-    const { sourceType, targetType, sessionId, options = {} } = req.body;
-
-    // 验证必需参数
-    if (!sourceType || !targetType || !sessionId) {
-      return res.status(400).json({
-        success: false,
-        error: 'Missing required parameters: sourceType, targetType, sessionId'
-      });
-    }
-
-    // 验证格式
-    const validTypes = ['claude', 'codex', 'gemini'];
-    if (!validTypes.includes(sourceType)) {
-      return res.status(400).json({
-        success: false,
-        error: `Invalid sourceType: ${sourceType}. Must be one of: ${validTypes.join(', ')}`
-      });
-    }
-    if (!validTypes.includes(targetType)) {
-      return res.status(400).json({
-        success: false,
-        error: `Invalid targetType: ${targetType}. Must be one of: ${validTypes.join(', ')}`
-      });
-    }
-    if (sourceType === targetType) {
-      return res.status(400).json({
-        success: false,
-        error: 'Source and target types must be different'
-      });
-    }
-
-    // 执行转换
-    const result = await convertSession(sourceType, targetType, sessionId, options);
-
-    res.json(result);
-  } catch (error) {
-    console.error('[Convert API] Conversion error:', error);
-    res.status(500).json({
-      success: false,
-      error: error.message
-    });
-  }
-});
 
 module.exports = router;

package/src/server/api/dashboard.js

@@ -1,19 +1,13 @@
 const express = require('express');
 const router = express.Router();
 const { loadConfig } = require('../../config/loader');
+const { getPlatformContext } = require('../platform-context');
 
 // Services
 const { loadUIConfig } = require('../services/ui-config');
 const { loadFavorites } = require('../services/favorites');
-const { getProxyStatus } = require('../proxy-server');
-const { getCodexProxyStatus } = require('../codex-proxy-server');
-const { getGeminiProxyStatus } = require('../gemini-proxy-server');
-const { getOpenCodeProxyStatus } = require('../opencode-proxy-server');
-const { getOmpProxyStatus } = require('../omp-proxy-server');
 const { getSnapshot } = require('../services/snapshot-cache');
-const { projectCountKey } = require('../services/project-snapshots');
-const { runDashboardSnapshotWorker } = require('../services/dashboard-snapshot-worker');
-
+const { runDashboardSourceWorker } = require('../services/dashboard-snapshot-worker');
 const SNAPSHOT_TTL_MS = 60 * 1000;
 const DASHBOARD_SNAPSHOT_DEFER_MS = 0;
 const EMPTY_COUNTS = { projectCount: 0, sessionCount: 0 };
@@ -28,12 +22,81 @@ function safeRead(label, reader, fallback) {
   }
 }
 
-function channelSnapshotKey(source) {
-  return `dashboard:channels:${source}`;
+function safeText(value, fallback = '') {
+  const text = typeof value === 'string'
+    ? value
+    : typeof value === 'number'
+      ? String(value)
+      : fallback;
+  return text.length > 1024 ? text.slice(0, 1024) : text;
+}
+
+function safeRetryAfter(value) {
+  return typeof value === 'string' || (typeof value === 'number' && Number.isFinite(value))
+    ? value
+    : undefined;
+}
+function safeCode(value) {
+  return typeof value === 'string' || (typeof value === 'number' && Number.isFinite(value))
+    ? value
+    : undefined;
 }
 
-function todayStatsSnapshotKey(source) {
-  return `dashboard:today-stats:${source}`;
+
+function resolveEnabledSources(uiConfig = {}, registry = getPlatformContext().registry) {
+  const definitions = registry?.list?.() || [];
+  const knownKeys = new Set(
+    definitions
+      .map(platform => String(platform?.key || '').trim().toLowerCase())
+      .filter(Boolean)
+  );
+  const requested = Array.isArray(uiConfig.enabledCliPlatforms)
+    ? uiConfig.enabledCliPlatforms
+    : (registry?.listDefaults?.({ enabledOnly: true }) || definitions)
+      .filter(platform => platform.defaultEnabled !== false)
+      .sort((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0))
+      .map(platform => platform.key);
+  const seen = new Set();
+
+  return requested
+    .map(platform => String(platform || '').trim().toLowerCase())
+    .filter(platform => {
+      if (!knownKeys.has(platform) || seen.has(platform)) return false;
+      seen.add(platform);
+      return true;
+    });
+}
+
+async function readProxyStatus(source, runtime) {
+  try {
+    const driver = runtime?.getDriver?.(source, 'proxy');
+    if (!driver || typeof driver.status !== 'function') {
+      return { status: 'unsupported', platform: source, capability: 'proxy', operation: 'status' };
+    }
+    return await driver.status();
+  } catch (error) {
+    const failure = {
+      status: typeof error?.status === 'string' ? safeText(error.status, 'failed') : 'failed',
+      platform: source,
+      capability: 'proxy',
+      operation: 'status',
+      error: safeText(error && error.message ? error.message : error, 'proxy status failed')
+    };
+    if (typeof error?.retryable === 'boolean') failure.retryable = error.retryable;
+    const retryAfter = safeRetryAfter(error?.retryAfter);
+    if (retryAfter !== undefined) {
+      failure.retryAfter = retryAfter;
+    }
+    const code = safeCode(error?.code);
+    if (code !== undefined) {
+      failure.code = code;
+    }
+    return failure;
+  }
+}
+
+function sourceSnapshotKey(source) {
+  return `dashboard:source:${source}`;
 }
 
 function normalizeChannelTokens(tokens) {
@@ -73,18 +136,45 @@ function formatStats(stats) {
   return { ...EMPTY_STATS };
 }
 
-async function readDashboardSnapshot(kind, source, key, fallbackValue, config = {}, options = {}) {
+async function readDashboardSnapshot(source, fallbackValue, config = {}, options = {}) {
   const force = options.force === true;
-  return getSnapshot(key, {
+  const key = sourceSnapshotKey(source);
+  const makeReadOptions = (effectiveForce) => ({
     ttlMs: SNAPSHOT_TTL_MS,
     fallbackValue,
-    force,
-    staleWhileForce: force,
+    force: effectiveForce,
+    staleWhileForce: effectiveForce,
     deferMs: DASHBOARD_SNAPSHOT_DEFER_MS,
-    refresh: () => runDashboardSnapshotWorker(kind, source, config, { force })
+    refresh: () => runDashboardSourceWorker(source, config, {
+      force: effectiveForce,
+      runtime: options.runtime
+    })
   });
+  const snapshot = await getSnapshot(key, makeReadOptions(force));
+  const generatedAtMs = Date.parse(snapshot.meta?.generatedAt || '');
+  const errorAgeMs = Number.isFinite(generatedAtMs) ? Date.now() - generatedAtMs : SNAPSHOT_TTL_MS;
+  if (!force
+    && errorAgeMs >= SNAPSHOT_TTL_MS
+    && Array.isArray(snapshot.value?.__errors)
+    && snapshot.value.__errors.length > 0) {
+    return getSnapshot(key, makeReadOptions(true));
+  }
+  return snapshot;
+}
+
+function sourceFallback(source, runtime) {
+  const channelsDriver = runtime?.getDriver?.(source, 'channels');
+  const channels = typeof channelsDriver?.normalizeDashboardChannels === 'function'
+    ? channelsDriver.normalizeDashboardChannels(null)
+    : { channels: [] };
+  return {
+    channels,
+    todayStats: null,
+    counts: EMPTY_COUNTS
+  };
 }
 
+
 function summarizePart(partSnapshots = {}) {
   const items = {};
   let stale = false;
@@ -125,104 +215,80 @@ function dashboardMeta(parts) {
  */
 router.get('/init', async (req, res) => {
   try {
-    const config = loadConfig();
+    const config = safeRead('config', () => loadConfig(), {});
     const force = req.query?.fresh === '1' || req.query?.force === '1';
-
     const uiConfig = safeRead('uiConfig', () => loadUIConfig(), {});
     const favorites = safeRead('favorites', () => loadFavorites(), {});
-    const proxyStatus = {
-      claude: safeRead('claude proxy status', () => getProxyStatus(), {}),
-      codex: safeRead('codex proxy status', () => getCodexProxyStatus(), {}),
-      gemini: safeRead('gemini proxy status', () => getGeminiProxyStatus(), {}),
-      opencode: safeRead('opencode proxy status', () => getOpenCodeProxyStatus(), {}),
-      omp: safeRead('omp proxy status', () => getOmpProxyStatus(), {})
-    };
-
-    const [
-      claudeChannels,
-      codexChannels,
-      geminiChannels,
-      opencodeChannels,
-      ompChannels,
-      claudeTodayStats,
-      codexTodayStats,
-      geminiTodayStats,
-      opencodeTodayStats,
-      ompTodayStats,
-      claudeCounts,
-      codexCounts,
-      geminiCounts,
-      opencodeCounts,
-      ompCounts
-    ] = await Promise.all([
-      readDashboardSnapshot('channels', 'claude', channelSnapshotKey('claude'), [], config, { force }),
-      readDashboardSnapshot('channels', 'codex', channelSnapshotKey('codex'), { channels: [] }, config, { force }),
-      readDashboardSnapshot('channels', 'gemini', channelSnapshotKey('gemini'), { channels: [] }, config, { force }),
-      readDashboardSnapshot('channels', 'opencode', channelSnapshotKey('opencode'), { channels: [] }, config, { force }),
-      readDashboardSnapshot('channels', 'omp', channelSnapshotKey('omp'), { channels: [] }, config, { force }),
-      readDashboardSnapshot('todayStats', 'claude', todayStatsSnapshotKey('claude'), null, config, { force }),
-      readDashboardSnapshot('todayStats', 'codex', todayStatsSnapshotKey('codex'), null, config, { force }),
-      readDashboardSnapshot('todayStats', 'gemini', todayStatsSnapshotKey('gemini'), null, config, { force }),
-      readDashboardSnapshot('todayStats', 'opencode', todayStatsSnapshotKey('opencode'), null, config, { force }),
-      readDashboardSnapshot('todayStats', 'omp', todayStatsSnapshotKey('omp'), null, config, { force }),
-      readDashboardSnapshot('counts', 'claude', projectCountKey('claude'), EMPTY_COUNTS, config, { force }),
-      readDashboardSnapshot('counts', 'codex', projectCountKey('codex'), EMPTY_COUNTS, config, { force }),
-      readDashboardSnapshot('counts', 'gemini', projectCountKey('gemini'), EMPTY_COUNTS, config, { force }),
-      readDashboardSnapshot('counts', 'opencode', projectCountKey('opencode'), EMPTY_COUNTS, config, { force }),
-      readDashboardSnapshot('counts', 'omp', projectCountKey('omp'), EMPTY_COUNTS, config, { force })
-    ]);
+    const { registry, runtime } = getPlatformContext();
+    const sources = resolveEnabledSources(uiConfig, registry);
+    const sourceFallbackPayload = source => sourceFallback(source, runtime);
+    const proxyStatusEntries = await Promise.all(sources.map(async source => [
+      source,
+      await readProxyStatus(source, runtime)
+    ]));
+    const proxyStatus = Object.fromEntries(proxyStatusEntries);
+    const sourceSnapshots = await Promise.all(sources.map(async (source) => {
+      const snapshot = await readDashboardSnapshot(
+        source,
+        sourceFallbackPayload(source),
+        config,
+        { force, runtime }
+      );
+      return [source, snapshot];
+    }));
+    const snapshotsBySource = Object.fromEntries(sourceSnapshots);
 
+    const capabilitySnapshot = (source, capability) => {
+      const snapshot = snapshotsBySource[source];
+      const value = snapshot?.value || sourceFallbackPayload(source);
+      const failure = Array.isArray(value.__errors)
+        ? value.__errors.find(error => error.capability === capability
+          || (capability === 'todayStats' && error.capability === 'statistics'))
+        : null;
+      const meta = { ...(snapshot?.meta || {}) };
+      if (failure) {
+        meta.stale = true;
+        meta.error = failure.error || 'dashboard capability failed';
+        if (failure.retryable !== undefined) meta.retryable = failure.retryable;
+        if (failure.retryAfter !== undefined) meta.retryAfter = failure.retryAfter;
+        if (failure.code !== undefined) meta.code = failure.code;
+      }
+      return { value: value[capability], meta };
+    };
     const parts = {
-      counts: summarizePart({
-        claude: claudeCounts,
-        codex: codexCounts,
-        gemini: geminiCounts,
-        opencode: opencodeCounts,
-        omp: ompCounts
-      }),
-      todayStats: summarizePart({
-        claude: claudeTodayStats,
-        codex: codexTodayStats,
-        gemini: geminiTodayStats,
-        opencode: opencodeTodayStats,
-        omp: ompTodayStats
-      }),
-      channels: summarizePart({
-        claude: claudeChannels,
-        codex: codexChannels,
-        gemini: geminiChannels,
-        opencode: opencodeChannels,
-        omp: ompChannels
-      })
+      counts: summarizePart(Object.fromEntries(sources.map(source => [source, capabilitySnapshot(source, 'counts')]))),
+      todayStats: summarizePart(Object.fromEntries(sources.map(source => [source, capabilitySnapshot(source, 'todayStats')]))),
+      channels: summarizePart(Object.fromEntries(sources.map(source => [source, capabilitySnapshot(source, 'channels')]))),
     };
+    const capabilityValueFor = (source, capability) => capabilitySnapshot(source, capability).value;
+    const channels = Object.fromEntries(sources.map(source => {
+      const value = capabilityValueFor(source, 'channels');
+      const driver = runtime?.getDriver?.(source, 'channels');
+      return [
+        source,
+        typeof driver?.normalizeDashboardChannels === 'function'
+          ? driver.normalizeDashboardChannels(value)
+          : value
+      ];
+    }));
+    const counts = Object.fromEntries(sources.map(source => [
+      source,
+      capabilityValueFor(source, 'counts') || EMPTY_COUNTS
+    ]));
+    const todayStats = Object.fromEntries(sources.map(source => [
+      source,
+      formatStats(capabilityValueFor(source, 'todayStats'))
+    ]));
 
     res.json({
       success: true,
       data: {
         uiConfig,
         favorites,
-        channels: {
-          claude: claudeChannels.value,
-          codex: codexChannels.value,
-          gemini: geminiChannels.value,
-          opencode: opencodeChannels.value.channels || [],
-          omp: ompChannels.value.channels || []
-        },
+        channels,
         proxyStatus,
-        counts: {
-          claude: claudeCounts.value || EMPTY_COUNTS,
-          codex: codexCounts.value || EMPTY_COUNTS,
-          gemini: geminiCounts.value || EMPTY_COUNTS,
-          opencode: opencodeCounts.value || EMPTY_COUNTS,
-          omp: ompCounts.value || EMPTY_COUNTS
-        },
-        todayStats: {
-          claude: formatStats(claudeTodayStats.value),
-          codex: formatStats(codexTodayStats.value),
-          gemini: formatStats(geminiTodayStats.value),
-          opencode: formatStats(opencodeTodayStats.value),
-          omp: formatStats(ompTodayStats.value)
-        },
+        counts,
+        todayStats,
         meta: dashboardMeta(parts)
       }
     });

package/src/server/api/hooks.js

@@ -1,6 +1,6 @@
 const express = require('express');
 const router = express.Router();
-const notificationHooks = require('../services/notification-hooks');
+const notificationHooks = require('../../platforms/notification-hooks');
 const { createSameOriginGuard, isLoopbackRequest } = require('../services/network-access');
 
 router.use(createSameOriginGuard({