coding-tool-x 3.8.3 → 3.8.5

package/src/server/services/model-detector.js

@@ -6,18 +6,19 @@
 const fs = require('fs');
 const path = require('path');
 const https = require('https');
+const { getPlatformCatalog } = require('./platform-catalog');
 const http = require('http');
 const { URL } = require('url');
 const crypto = require('crypto');
 const zlib = require('zlib');
 const { loadConfig } = require('../../config/loader');
-const { createCodexRequest, buildCodexTargetUrl } = require('./codex-wire');
-const { createClaudeRequest, buildClaudeTargetUrl } = require('./claude-wire');
+const { createCodexRequest, buildCodexTargetUrl } = require('../../platforms/drivers/codex/wire');
+const { createClaudeRequest, buildClaudeTargetUrl } = require('../../platforms/drivers/claude/wire');
 const {
   createGeminiRequest,
   buildGeminiTargetUrl,
   shouldUseGeminiCliFormat
-} = require('./gemini-wire');
+} = require('../../platforms/drivers/gemini/wire');
 const { PATHS } = require('../../config/paths');
 
 // 内置模型优先级（当配置缺失时兜底）
@@ -60,11 +61,14 @@ MODEL_PRIORITY.openai_compatible = MODEL_PRIORITY.codex;
 
 function normalizeModelToolType(type) {
   const value = String(type || '').trim().toLowerCase();
+  if (!value) return '';
   if (value === 'openai_compatible') return 'codex';
-  if (value === 'claude' || value === 'codex' || value === 'gemini' || value === 'opencode') {
-    return value;
-  }
-  return '';
+  return value;
+}
+
+function getModelCatalogKey(toolType) {
+  const manifest = getPlatformCatalog().get(toolType);
+  return manifest?.modelConfig?.catalogKey || toolType;
 }
 
 /**
@@ -88,12 +92,12 @@ function getModelPriority(channelType, options = {}) {
   if (String(channelType || '').trim().toLowerCase() === 'openai_compatible' && !candidateTypes.includes('openai_compatible')) {
     candidateTypes.push('openai_compatible');
   }
-
   try {
     const config = loadConfig();
     const defaultModels = config?.defaultModels || {};
     for (const toolType of candidateTypes) {
-      const models = defaultModels[toolType];
+      const catalogKey = getModelCatalogKey(toolType);
+      const models = defaultModels[catalogKey] || defaultModels[toolType];
       if (Array.isArray(models) && models.length > 0) {
         return normalizeModelCandidates(models);
       }
@@ -103,7 +107,8 @@ function getModelPriority(channelType, options = {}) {
   }
 
   for (const toolType of candidateTypes) {
-    const models = MODEL_PRIORITY[toolType];
+    const catalogKey = getModelCatalogKey(toolType);
+    const models = MODEL_PRIORITY[catalogKey] || MODEL_PRIORITY[toolType];
     if (Array.isArray(models) && models.length > 0) {
       return normalizeModelCandidates(models);
     }

package/src/server/services/native-log-channel-resolver.js

@@ -0,0 +1,214 @@
+'use strict';
+
+const CHANNEL_PLACEHOLDERS = new Set(['', 'unknown', 'unkonwn', 'n/a', 'na', 'none', '-']);
+
+function text(value) {
+  return typeof value === 'string' ? value.trim() : String(value || '').trim();
+}
+
+function normalizeIdentity(value) {
+  return text(value).toLowerCase();
+}
+
+function isChannelPlaceholder(value) {
+  return CHANNEL_PLACEHOLDERS.has(normalizeIdentity(value));
+}
+
+function meaningfulText(value) {
+  const result = text(value);
+  return isChannelPlaceholder(result) ? '' : result;
+}
+
+function identityAliases(value) {
+  const normalized = normalizeIdentity(value);
+  if (!normalized) return [];
+  const aliases = new Set([normalized]);
+  if (normalized.startsWith('ctx-')) aliases.add(normalized.slice(4));
+  if (normalized.startsWith('provider:')) aliases.add(normalized.slice('provider:'.length));
+  return [...aliases].filter(Boolean);
+}
+
+function normalizeUrl(value) {
+  const raw = text(value);
+  if (!raw) return '';
+  try {
+    const url = new URL(raw);
+    url.hash = '';
+    url.search = '';
+    url.pathname = url.pathname.replace(/\/+$/, '');
+    return url.toString().toLowerCase().replace(/\/$/, '');
+  } catch (_) {
+    return raw.toLowerCase().replace(/\/+$/, '');
+  }
+}
+
+function unwrapChannels(value) {
+  if (value && typeof value === 'object' && typeof value.status === 'string' && value.status !== 'ok') {
+    return [];
+  }
+  const data = value && typeof value === 'object' && Object.prototype.hasOwnProperty.call(value, 'data')
+    ? value.data
+    : value;
+  const channels = Array.isArray(data) ? data : data?.channels;
+  return Array.isArray(channels) ? channels.filter(channel => channel && typeof channel === 'object') : [];
+}
+
+function nestedValues(source, keys) {
+  if (!source || typeof source !== 'object') return [];
+  const values = [];
+  for (const key of keys) {
+    if (source[key] != null) values.push(source[key]);
+  }
+  return values;
+}
+
+function channelSources(channel) {
+  return [channel, channel?.extra, channel?.providerConfig]
+    .filter(source => source && typeof source === 'object');
+}
+
+function channelIdentityValues(channel) {
+  const values = [];
+  for (const source of channelSources(channel)) {
+    values.push(...nestedValues(source, [
+      'id', 'name', 'providerKey', 'provider', 'providerId', 'providerID',
+      'managedProviderId', 'oauthProviderId', 'providerName'
+    ]));
+    if (source.authRef && typeof source.authRef === 'object') {
+      values.push(...nestedValues(source.authRef, ['providerId', 'providerID', 'accountId', 'identityKey']));
+    }
+  }
+  return values.flatMap(identityAliases);
+}
+
+function eventIdentityValues(event) {
+  return nestedValues(event, [
+    'provider', 'providerKey', 'providerId', 'providerID', 'managedProviderId', 'oauthProviderId'
+  ]).flatMap(identityAliases);
+}
+
+function channelUrlValues(channel) {
+  const values = [];
+  for (const source of channelSources(channel)) {
+    values.push(...nestedValues(source, ['baseUrl', 'baseURL', 'apiBaseUrl', 'apiBaseURL', 'endpoint', 'url']));
+  }
+  return values.map(normalizeUrl).filter(Boolean);
+}
+
+function eventUrlValues(event) {
+  return nestedValues(event, [
+    'baseUrl', 'baseURL', 'apiBaseUrl', 'apiBaseURL', 'endpoint', 'url', 'providerBaseUrl'
+  ])
+    .concat(event?.providerConfig && typeof event.providerConfig === 'object'
+      ? nestedValues(event.providerConfig, ['baseUrl', 'baseURL', 'apiBaseUrl', 'apiBaseURL', 'endpoint', 'url'])
+      : [])
+    .map(normalizeUrl)
+    .filter(Boolean);
+}
+
+function modelAliases(value) {
+  const normalized = normalizeIdentity(value);
+  if (!normalized) return [];
+  const aliases = new Set([normalized]);
+  const slashIndex = normalized.lastIndexOf('/');
+  if (slashIndex >= 0) aliases.add(normalized.slice(slashIndex + 1));
+  return [...aliases].filter(Boolean);
+}
+
+function modelValues(value) {
+  if (Array.isArray(value)) return value.flatMap(modelValues);
+  if (value && typeof value === 'object') {
+    return nestedValues(value, ['id', 'name', 'model', 'modelId', 'modelID']).flatMap(modelValues);
+  }
+  return modelAliases(value);
+}
+
+function channelModelValues(channel) {
+  const values = [];
+  for (const source of channelSources(channel)) {
+    values.push(...nestedValues(source, [
+      'model', 'models', 'allowedModels', 'modelConfig', 'modelRedirects', 'modelBindings'
+    ]).flatMap(modelValues));
+  }
+  return values;
+}
+
+function eventModelValues(event) {
+  return modelAliases(event?.model || event?.modelId || event?.modelID);
+}
+
+function matchesBy(channels, values, getValues) {
+  const wanted = new Set(values);
+  if (!wanted.size) return [];
+  return channels.filter(channel => getValues(channel).some(value => wanted.has(value)));
+}
+
+function matchedChannel(channel) {
+  const channelId = text(channel?.id);
+  const channelName = text(channel?.name) || text(channel?.providerKey) || channelId;
+  return {
+    ...(channelId ? { channelId } : {}),
+    ...(channelName ? { channel: channelName } : {})
+  };
+}
+
+function fallbackChannel(event) {
+  const channel = meaningfulText(event?.channel) || meaningfulText(event?.provider)
+    || meaningfulText(event?.providerKey) || meaningfulText(event?.providerId)
+    || meaningfulText(event?.channelId);
+  return channel ? { channel } : {};
+}
+
+/**
+ * Resolve the configured channel responsible for a native CLI usage event.
+ * Native log formats do not agree on a channel field, so provider/model metadata
+ * is matched against the channel registry at the observation boundary.
+ */
+function resolveNativeLogChannel(event = {}, channels = []) {
+  const allChannels = unwrapChannels(channels);
+  const enabledChannels = allChannels.filter(channel => channel.enabled !== false);
+
+  const explicitId = normalizeIdentity(event.channelId);
+  if (explicitId) {
+    const match = allChannels.find(channel => normalizeIdentity(channel.id) === explicitId);
+    if (match) return matchedChannel(match);
+    return { channelId: text(event.channelId), channel: text(event.channel) || text(event.channelId) };
+  }
+
+  const explicitChannel = isChannelPlaceholder(event.channel) ? '' : normalizeIdentity(event.channel);
+  if (explicitChannel) {
+    const matches = matchesBy(allChannels, identityAliases(event.channel), channelIdentityValues);
+    if (matches.length === 1) return matchedChannel(matches[0]);
+    return { channel: meaningfulText(event.channel) };
+  }
+
+  const providerMatches = matchesBy(allChannels, eventIdentityValues(event), channelIdentityValues);
+  if (providerMatches.length === 1) return matchedChannel(providerMatches[0]);
+
+  const eventUrls = eventUrlValues(event);
+  const eventModels = eventModelValues(event);
+  if (providerMatches.length > 1 && eventModels.length) {
+    const providerModelMatches = matchesBy(providerMatches, eventModels, channelModelValues);
+    if (providerModelMatches.length === 1) return matchedChannel(providerModelMatches[0]);
+  }
+  if (providerMatches.length > 1 && eventUrls.length) {
+    const providerUrlMatches = matchesBy(providerMatches, eventUrls, channelUrlValues);
+    if (providerUrlMatches.length === 1) return matchedChannel(providerUrlMatches[0]);
+  }
+
+  if (eventUrls.length) {
+    const urlMatches = matchesBy(allChannels, eventUrls, channelUrlValues);
+    if (urlMatches.length === 1) return matchedChannel(urlMatches[0]);
+  }
+  if (eventModels.length) {
+    const modelMatches = matchesBy(allChannels, eventModels, channelModelValues);
+    if (modelMatches.length === 1) return matchedChannel(modelMatches[0]);
+  }
+
+  // A provider-less native format is still resolvable when only one channel is
+  // currently enabled. Do not guess when several channels could have produced it.
+  if (enabledChannels.length === 1) return matchedChannel(enabledChannels[0]);
+  return fallbackChannel(event);
+}
+
+module.exports = { resolveNativeLogChannel, unwrapChannels, isChannelPlaceholder };

package/src/server/services/native-log-observer.js

@@ -0,0 +1,291 @@
+'use strict';
+
+const eventBus = require('../../plugins/event-bus');
+const { getPlatformRegistry, getPlatformRuntime } = require('../../platforms/runtime');
+const { buildSuccessLogPayload, hasMeaningfulUsage, normalizeUsageTokens } = require('./usage-log-utils');
+const { resolveNativeLogChannel, unwrapChannels, isChannelPlaceholder } = require('./native-log-channel-resolver');
+const { broadcastLog } = require('../websocket-server');
+
+const DEFAULT_INTERVAL_MS = 5000;
+let pollTimer = null;
+let enabled = false;
+let intervalMs = DEFAULT_INTERVAL_MS;
+let cursors = new Map();
+let cursorDiagnostics = new Map();
+let firstPollObserved = false;
+let configSavedListener = null;
+let lifecycleState = 'stopped';
+
+function memoryTraceEnabled() {
+  return process.env.CC_TOOL_MEMORY_TRACE === '1';
+}
+
+function traceMemory(platform, stage, details = {}, durationMs = null) {
+  if (!memoryTraceEnabled()) return;
+  const usage = process.memoryUsage();
+  const payload = {
+    pid: process.pid,
+    platform,
+    stage,
+    ...(durationMs === null ? {} : { durationMs: Number(durationMs.toFixed(3)) }),
+    files: Number(details.files) || 0,
+    bytesRead: Number(details.bytesRead) || 0,
+    parsedRecords: Number(details.parsedRecords) || 0,
+    maxLineLength: Number(details.maxLineLength) || 0,
+    rss: usage.rss,
+    heapTotal: usage.heapTotal,
+    heapUsed: usage.heapUsed,
+    external: usage.external,
+    arrayBuffers: usage.arrayBuffers
+  };
+  console.log(`[MEM] native-log ${JSON.stringify(payload)}`);
+}
+
+function traceClock() {
+  return Number(process.hrtime.bigint()) / 1e6;
+}
+
+function normalizeInterval(value) {
+  const seconds = Number(value);
+  return Number.isFinite(seconds) && seconds >= 1 && seconds <= 60
+    ? seconds * 1000
+    : DEFAULT_INTERVAL_MS;
+}
+
+function getStatus() {
+  return {
+    running: Boolean(pollTimer),
+    state: lifecycleState,
+    enabled,
+    intervalMs,
+    platforms: [...cursors.keys()]
+  };
+}
+
+function closeCursor(cursor) {
+  try { cursor?.close?.(); } catch (_) {}
+}
+
+function resolveCursors(runtime = getPlatformRuntime(), registry = getPlatformRegistry()) {
+  const next = new Map();
+  const traceEnabled = memoryTraceEnabled();
+  const platforms = registry.list({ enabledOnly: true });
+  for (const platform of platforms) {
+    const key = platform.key;
+    let driver;
+    try { driver = runtime.getDriver(key, 'nativeLogs'); } catch (_) { driver = null; }
+    if (!driver || typeof driver.createNativeLogCursor !== 'function') continue;
+
+    const existing = cursors.get(key);
+    let cursor = existing;
+    if (!cursor) {
+      const options = { skipInitialParse: true };
+      if (traceEnabled) {
+        options.onDiagnostic = details => cursorDiagnostics.set(key, details || {});
+      }
+      cursor = driver.createNativeLogCursor(options);
+      const startedAt = traceClock();
+      traceMemory(key, 'cursor-initialize-before', {}, 0);
+      try { cursor.initialize?.(); } catch (error) {
+        console.warn(`[Native Logs] Failed to initialize ${key}:`, error.message);
+      }
+      traceMemory(key, 'cursor-initialize-after', cursorDiagnostics.get(key), traceClock() - startedAt);
+    }
+    next.set(key, cursor);
+  }
+  for (const [key, cursor] of cursors) {
+    if (!next.has(key)) {
+      closeCursor(cursor);
+      cursorDiagnostics.delete(key);
+    }
+  }
+  cursors = next;
+}
+
+function readConfiguredChannels(platform, runtime) {
+  let driver;
+  try { driver = runtime.getDriver(platform, 'channels'); } catch (_) { driver = null; }
+  if (!driver) return [];
+
+  // Read the full list first: a historical event may belong to a channel that
+  // was disabled after the CLI emitted the record.
+  for (const method of ['list', 'getChannels', 'getEnabled']) {
+    if (typeof driver[method] !== 'function') continue;
+    try {
+      const result = driver[method]();
+      if (result && typeof result.then === 'function') continue;
+      const channels = unwrapChannels(result);
+      if (channels.length) return channels;
+    } catch (_) {}
+  }
+  return [];
+}
+
+function recordEvent(platform, event, runtime = getPlatformRuntime(), channelCache = new Map()) {
+  const timestampValue = event.timestamp ? new Date(event.timestamp).getTime() : Date.now();
+  const timestamp = Number.isFinite(timestampValue) ? timestampValue : Date.now();
+  const tokens = normalizeUsageTokens(platform, event.tokens || event.usage || {});
+  if (!hasMeaningfulUsage(platform, tokens)) return false;
+  if (!channelCache.has(platform)) channelCache.set(platform, readConfiguredChannels(platform, runtime));
+  const resolvedChannel = resolveNativeLogChannel(event, channelCache.get(platform));
+  const channel = resolvedChannel.channel
+    || (isChannelPlaceholder(event.channel) ? '' : event.channel)
+    || (isChannelPlaceholder(event.provider) ? '' : event.provider)
+    || 'Unknown';
+  const channelId = resolvedChannel.channelId || event.channelId;
+
+  broadcastLog(buildSuccessLogPayload({
+    source: platform,
+    requestId: event.id,
+    channel,
+    model: event.model || '',
+    tokens,
+    cost: Number(event.cost) || 0,
+    timestamp,
+    usageMissing: false
+  }));
+
+  let statistics;
+  try { statistics = runtime.getDriver(platform, 'statistics'); } catch (_) { statistics = null; }
+  if (statistics && typeof statistics.recordRequest === 'function') {
+    statistics.recordRequest({
+      id: event.id,
+      timestamp: new Date(timestamp).toISOString(),
+      session: event.sessionId || null,
+      model: event.model || '',
+      channel,
+      channelId,
+      tokens,
+      cost: Number(event.cost) || 0,
+      duration: 0,
+      success: true
+    });
+  }
+  return true;
+}
+
+function pollNativeCliLogs({ runtime = getPlatformRuntime(), registry = getPlatformRegistry() } = {}) {
+  if (!enabled) return getStatus();
+  resolveCursors(runtime, registry);
+  const channelCache = new Map();
+  const traceFirstPoll = memoryTraceEnabled() && !firstPollObserved;
+  for (const [platform, cursor] of cursors) {
+    const startedAt = traceFirstPoll ? traceClock() : 0;
+    if (traceFirstPoll) traceMemory(platform, 'first-poll-before', cursorDiagnostics.get(platform), 0);
+    try {
+      const events = cursor.readNewEvents?.() || cursor.read?.() || [];
+      events.forEach(event => recordEvent(platform, event, runtime, channelCache));
+    } catch (error) {
+      console.warn(`[Native Logs] Failed to read ${platform}:`, error.message);
+    } finally {
+      if (traceFirstPoll) traceMemory(platform, 'first-poll-after', cursorDiagnostics.get(platform), traceClock() - startedAt);
+    }
+  }
+  if (traceFirstPoll) firstPollObserved = true;
+  return getStatus();
+}
+
+function clearTimer() {
+  if (pollTimer) clearInterval(pollTimer);
+  pollTimer = null;
+}
+
+function startTimer(options) {
+  clearTimer();
+  pollTimer = setInterval(() => {
+    try { pollNativeCliLogs(options); } catch (error) {
+      console.warn('[Native Logs] Poll failed:', error.message);
+    }
+  }, intervalMs);
+  if (typeof pollTimer.unref === 'function') pollTimer.unref();
+}
+
+function ensureConfigListener(options) {
+  if (configSavedListener) return;
+  configSavedListener = ({ config } = {}) => {
+    const next = config?.nativeCliLogs || {};
+    const nextOptions = { ...options, enabled: next.enabled, intervalSeconds: next.intervalSeconds };
+    if (lifecycleState === 'running') {
+      configureNativeCliLogObserver(nextOptions);
+    } else {
+      prepareNativeCliLogObserver(nextOptions);
+    }
+  };
+  eventBus.on('config:saved', configSavedListener);
+}
+
+function prepareNativeCliLogObserver({
+  enabled: nextEnabled = true,
+  intervalSeconds = 5,
+  runtime = getPlatformRuntime(),
+  registry = getPlatformRegistry()
+} = {}) {
+  ensureConfigListener({ runtime, registry });
+  enabled = nextEnabled !== false;
+  intervalMs = normalizeInterval(intervalSeconds);
+  if (!enabled) {
+    clearTimer();
+    for (const cursor of cursors.values()) closeCursor(cursor);
+    cursors = new Map();
+    cursorDiagnostics = new Map();
+    firstPollObserved = false;
+    lifecycleState = 'stopped';
+    return getStatus();
+  }
+  resolveCursors(runtime, registry);
+  if (pollTimer) clearTimer();
+  lifecycleState = 'prepared';
+  return getStatus();
+}
+
+function startNativeCliLogObserver({
+  runtime = getPlatformRuntime(),
+  registry = getPlatformRegistry(),
+  pollImmediately = true
+} = {}) {
+  if (!enabled) return getStatus();
+  resolveCursors(runtime, registry);
+  if (pollImmediately) {
+    try { pollNativeCliLogs({ runtime, registry }); } catch (error) {
+      console.warn('[Native Logs] Initial poll failed:', error.message);
+    }
+  }
+  startTimer({ runtime, registry });
+  lifecycleState = 'running';
+  return getStatus();
+}
+
+function configureNativeCliLogObserver(options = {}) {
+  prepareNativeCliLogObserver(options);
+  return startNativeCliLogObserver({
+    ...options,
+    // Preserve the legacy configure() behavior: it starts the interval but
+    // does not synchronously consume a new batch of native logs.
+    pollImmediately: options.pollImmediately === true
+  });
+}
+
+function shutdownNativeCliLogObserver() {
+  clearTimer();
+  for (const cursor of cursors.values()) closeCursor(cursor);
+  cursors = new Map();
+  cursorDiagnostics = new Map();
+  firstPollObserved = false;
+  enabled = false;
+  intervalMs = DEFAULT_INTERVAL_MS;
+  lifecycleState = 'stopped';
+  if (configSavedListener) {
+    eventBus.off('config:saved', configSavedListener);
+    configSavedListener = null;
+  }
+  return getStatus();
+}
+
+module.exports = {
+  prepareNativeCliLogObserver,
+  startNativeCliLogObserver,
+  configureNativeCliLogObserver,
+  shutdownNativeCliLogObserver,
+  pollNativeCliLogs,
+  _test: { getStatus, recordEvent, resolveCursors, readConfiguredChannels }
+};

package/src/server/services/network-access.js

@@ -73,7 +73,7 @@ function createRemoteMutationGuard(options = {}) {
 }
 
 function isRemoteMutationAllowedByEnv(env = process.env) {
-  return String(env.CC_TOOL_ALLOW_REMOTE_WRITE || '').toLowerCase() !== 'false';
+  return String(env.CC_TOOL_ALLOW_REMOTE_WRITE || '').toLowerCase() === 'true';
 }
 
 function createRemoteRouteGuard(options = {}) {

package/src/server/services/platform-catalog.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const { normalizePlatformKey } = require('../../shared/platforms');
+const { getPlatformContext } = require('../platform-context');
+
+const WEB_UI_PORT = 19999;
+
+function isSupportedCapability(manifest, capability) {
+  if (!capability) return true;
+  const driver = manifest?.capabilities?.[capability];
+  return driver !== undefined && driver !== null && driver !== 'unsupported';
+}
+
+function supportsResourceType(manifest, resourceType) {
+  if (!resourceType) return true;
+  if (manifest?.resourceTypes?.[resourceType] === false) return false;
+  return isSupportedCapability(manifest, 'resourceSync');
+}
+
+function createPlatformCatalog({ registry, runtime } = {}) {
+  if (!registry || typeof registry.list !== 'function') {
+    throw new TypeError('Platform catalog requires a registry');
+  }
+  if (!runtime || typeof runtime.getDriver !== 'function') {
+    throw new TypeError('Platform catalog requires a runtime');
+  }
+
+  function list({ capability, resourceType, enabledOnly = true } = {}) {
+    return registry.list({ enabledOnly })
+      .filter(manifest => manifest && manifest.key)
+      .filter(manifest => isSupportedCapability(manifest, capability))
+      .filter(manifest => supportsResourceType(manifest, resourceType));
+  }
+
+  function get(key) {
+    const normalizedKey = normalizePlatformKey(key);
+    return normalizedKey ? list({ enabledOnly: false }).find(manifest => (
+      normalizePlatformKey(manifest.key) === normalizedKey
+    )) || null : null;
+  }
+
+  function driver(key, capability) {
+    const manifest = get(key);
+    if (!manifest || !isSupportedCapability(manifest, capability)) return null;
+    const driverId = manifest.capabilities?.[capability];
+    if (!driverId || driverId === 'unsupported') return null;
+    const driver = runtime.getDriver(manifest.key, capability);
+    return driver && driver.status === 'unsupported' ? null : driver;
+  }
+
+  function ports() {
+    const entries = [{ key: 'webUI', defaultPort: WEB_UI_PORT, label: 'Web UI', platform: null }];
+    for (const manifest of list({ enabledOnly: true })) {
+      if (!manifest.portKey || !Number.isFinite(manifest.defaultPort)) continue;
+      entries.push({
+        key: manifest.portKey,
+        defaultPort: manifest.defaultPort,
+        label: manifest.portLabel || manifest.label || manifest.key,
+        platform: manifest.key
+      });
+    }
+    return entries;
+  }
+
+  return Object.freeze({
+    list,
+    keys(options = {}) {
+      return list(options).map(manifest => normalizePlatformKey(manifest.key));
+    },
+    get,
+    driver,
+    ports
+  });
+}
+
+
+function getPlatformCatalog() {
+  const context = getPlatformContext();
+  return createPlatformCatalog(context);
+}
+
+module.exports = { createPlatformCatalog, getPlatformCatalog, WEB_UI_PORT };