coding-tool-x 3.8.3 → 3.8.5

package/src/server/api/platform-route-factory.js

@@ -0,0 +1,215 @@
+'use strict';
+
+const { applyRequestCodec, applyResponseCodec } = require('./platform-api-config');
+
+const STATUS_CODES = Object.freeze({ ok: 200, invalid: 400, conflict: 409, unprocessable: 422, unsupported: 404, unavailable: 503, failed: 500 });
+
+const DEFAULT_ROUTES = Object.freeze([
+  { method: 'GET', path: '/projects', capability: 'projects', operation: 'listProjects', request: 'projects-list', response: 'projects-list' },
+  { method: 'GET', path: '/sessions/:projectName', capability: 'sessions', operation: 'listSessions', request: 'sessions-list', response: 'sessions-list' },
+  { method: 'GET', path: '/channels', capability: 'channels', operation: 'list', request: 'default', response: 'default' },
+  { method: 'POST', path: '/channels', capability: 'channels', operation: 'create', request: 'default', response: 'default' },
+  { method: 'PUT', path: '/channels/:channelId', capability: 'channels', operation: 'update', request: 'default', response: 'default' },
+  { method: 'DELETE', path: '/channels/:channelId', capability: 'channels', operation: 'remove', request: 'default', response: 'default' },
+  { method: 'GET', path: '/proxy/status', capability: 'proxy', operation: 'status', request: 'default', response: 'default' }
+]);
+
+function isObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function safeText(value, fallback) {
+  if (value == null || value === '') return fallback;
+  return String(value).slice(0, 4096);
+}
+
+function addContext(value, { platform, capability, operation }) {
+  const result = isObject(value) ? { ...value } : {};
+  if (result.platform == null) result.platform = platform;
+  if (result.capability == null) result.capability = capability;
+  if (result.operation == null) result.operation = operation;
+  if (result.code == null && result.status && result.status !== 'ok') result.code = result.status;
+  return result;
+}
+
+function makeFailure(context, error) {
+  const cause = error instanceof Error ? error : new Error(safeText(error, 'Platform route failed'));
+  const status = cause.statusCode === 409 ? 'conflict'
+    : cause.statusCode === 422 ? 'unprocessable'
+      : cause.statusCode === 400 ? 'invalid'
+        : cause.statusCode === 503 ? 'unavailable' : 'failed';
+  const result = {
+    status,
+    code: cause.code || status,
+    platform: context.platform,
+    capability: context.capability,
+    operation: context.operation,
+    error: safeText(cause.message, 'Platform route failed')
+  };
+  if (cause.conflictingChannelId) result.conflictingChannelId = cause.conflictingChannelId;
+  if (cause.conflictingChannelName) result.conflictingChannelName = cause.conflictingChannelName;
+  Object.defineProperty(result, 'cause', { value: cause, enumerable: false });
+  return result;
+}
+
+function makeUnsupported(context) {
+  return {
+    status: 'unsupported',
+
+    code: 'unsupported',
+    platform: context.platform,
+    capability: context.capability,
+    operation: context.operation
+  };
+}
+function legacyArguments(route, request) {
+  if (route.capability === 'projects' && route.operation === 'listProjects') return [{ force: request.query?.fresh === '1' }];
+  if (route.capability === 'sessions' && route.operation === 'listSessions') {
+    return [request.params.projectName, { force: request.query?.fresh === '1' }];
+  }
+  if (route.capability === 'channels') {
+    if (route.method === 'POST') return [request.body || {}];
+    if (route.method === 'PUT') return [request.params.channelId, request.body || {}];
+    if (route.method === 'DELETE') return [request.params.channelId];
+    return [{ force: request.query?.fresh === '1' }];
+  }
+  if (route.capability === 'proxy') return [{ force: request.query?.fresh === '1' }];
+  return [];
+}
+
+function makeSuccess(context, data) {
+  return { status: 'ok', platform: context.platform, capability: context.capability, operation: context.operation, data };
+}
+
+function resolvePlatform(registry, key) {
+  return registry && typeof registry.resolve === 'function' ? registry.resolve(key) : null;
+}
+
+function getDeclaredCapability(registry, platform, definition, capability) {
+  if (registry && typeof registry.getCapability === 'function') return registry.getCapability(platform, capability);
+  return definition?.capabilities?.[capability];
+}
+
+function normalizeResult(value, context) {
+  if (isObject(value) && typeof value.status === 'string') return addContext(value, context);
+  return makeSuccess(context, value);
+}
+
+function sendDriverResult(response, value, route, context) {
+  const result = normalizeResult(value, context);
+  const statusCode = STATUS_CODES[result.status];
+  if (!statusCode) return response.status(500).json({ error: makeFailure(context, new Error('Invalid Driver result status')) });
+  if (result.status === 'ok') {
+    const payload = applyResponseCodec(Object.prototype.hasOwnProperty.call(result, 'data') ? result.data : result, context.manifest, route, context);
+    return response.status(200).json(payload);
+  }
+  return response.status(statusCode).json({ error: result });
+}
+
+function routePlatform(request, manifest) {
+  return String(request.params.platform || manifest.key || '').trim().toLowerCase();
+}
+
+function sendLegacyResult(response, value, route, context) {
+  if (isObject(value) && typeof value.status === 'string') {
+    return sendDriverResult(response, value, route, context);
+  }
+  return response.status(200).json(value);
+}
+
+async function invokeRoute({ registry, runtime, config, request, response, manifest: suppliedManifest, route }) {
+  const platform = routePlatform(request, suppliedManifest || {});
+  const manifest = suppliedManifest?.key === platform
+    ? suppliedManifest
+    : resolvePlatform(registry, platform);
+  const operation = route.operation;
+  const context = { platform, manifest, config, capability: route.capability, operation };
+
+  if (!manifest) {
+    return response.status(404).json({ error: { status: 'invalid', code: 'not_found', platform, capability: route.capability, operation, error: `Unknown platform: ${platform}` } });
+  }
+
+  const legacyRoute = !manifest.api?.routes;
+  const declaredCapability = getDeclaredCapability(registry, platform, manifest, route.capability);
+  const absentCapability = declaredCapability === null || declaredCapability === undefined || declaredCapability === 'unsupported';
+  if (absentCapability) {
+    return sendDriverResult(response, makeUnsupported(context), route, context);
+  }
+
+  let driver;
+  const isDescriptorRoute = Boolean(manifest.api?.routes);
+  try {
+    driver = runtime?.getDriver?.(
+      platform,
+      route.capability,
+      { config, manifest, route, apiRoute: isDescriptorRoute }
+    );
+  } catch (error) {
+    return sendDriverResult(response, makeFailure(context, error), route, context);
+  }
+  if (!driver || typeof driver[operation] !== 'function') {
+    return sendDriverResult(response, makeUnsupported(context), route, context);
+  }
+
+  try {
+    const invocation = isDescriptorRoute
+      ? applyRequestCodec(request, manifest, route, config)
+      : legacyArguments(route, request);
+    const value = isDescriptorRoute
+      ? await driver[operation](invocation)
+      : await driver[operation](...invocation);
+    return isDescriptorRoute
+      ? sendDriverResult(response, value, route, { ...context, ...invocation })
+      : sendLegacyResult(response, value, route, context);
+  } catch (error) {
+    return sendDriverResult(response, makeFailure(context, error), route, context);
+  }
+}
+
+function normalizeRoute(route) {
+  return { method: 'GET', ...route, method: String(route.method || 'GET').toUpperCase() };
+}
+
+function joinPath(prefix, routePath) {
+  const left = String(prefix || '').replace(/\/$/, '');
+  const right = String(routePath || '/');
+  return `${left}${right.startsWith('/') ? right : `/${right}`}` || '/';
+}
+
+function createPlatformRouteFactory({ registry, runtime, config } = {}) {
+  function routesFor(manifest) {
+    return (manifest?.api?.routes || DEFAULT_ROUTES).map(normalizeRoute);
+  }
+
+  function createHandler(manifest, route) {
+    return (request, response) => invokeRoute({ registry, runtime, config, request, response, manifest, route });
+  }
+
+  return {
+    routesFor,
+    createHandler,
+    mount(router, { manifest, basePath = '/:platform', aliases = false } = {}) {
+      const definitions = manifest
+        ? [manifest]
+        : (registry?.list?.({ enabledOnly: true }) || []);
+      const manifests = definitions.length > 0 || !basePath.includes(':platform')
+        ? definitions
+        : [null];
+      for (const definition of manifests) {
+        for (const route of routesFor(definition)) {
+          if (aliases && !definition?.api?.rootAlias) continue;
+          const firstSegment = route.path.split('/').filter(Boolean)[0];
+          if (aliases && !definition.api.rootAliasPaths?.includes(firstSegment)) continue;
+          const path = joinPath(basePath, route.path);
+          router[route.method.toLowerCase()](path, createHandler(definition, route));
+        }
+      }
+      return router;
+    },
+    invokeRoute
+  };
+}
+
+module.exports = createPlatformRouteFactory;
+module.exports.createPlatformRouteFactory = createPlatformRouteFactory;
+module.exports._test = { addContext, makeFailure, makeUnsupported, sendDriverResult, invokeRoute, normalizeResult };

package/src/server/api/platform-routes.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const express = require('express');
+const createPlatformRouteFactory = require('./platform-route-factory');
+
+
+function mountPlatformApi(router, manifest, factory) {
+  if (!manifest?.api?.prefix) return;
+  factory.mount(router, { manifest, basePath: `/${manifest.api.prefix}` });
+  if (manifest.api.rootAlias) factory.mount(router, { manifest, basePath: '/', aliases: true });
+}
+
+function createPlatformApiRouter({ registry, runtime, config } = {}) {
+  const router = express.Router();
+  const factory = createPlatformRouteFactory({ registry, runtime, config });
+  const manifests = registry?.list?.({ enabledOnly: true }) || [];
+
+  for (const manifest of manifests) {
+    mountPlatformApi(router, manifest, factory);
+  }
+
+  return router;
+}
+
+module.exports = createPlatformApiRouter;
+module.exports.mountPlatformApi = mountPlatformApi;

package/src/server/api/platforms.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const express = require('express');
+const createPlatformRouteFactory = require('./platform-route-factory');
+
+const PUBLIC_FIELDS = Object.freeze([
+  'key',
+  'label',
+  'title',
+  'command',
+  'iconToken',
+  'color',
+  'defaultVisible',
+  'defaultEnabled',
+  'sortOrder',
+  'portKey',
+  'defaultPort',
+  'portLabel',
+  'apiPrefix',
+  'modelCatalogKey',
+  'promptLabel',
+  'resourceTypes'
+]);
+
+function publicCapabilities(capabilities) {
+  if (!capabilities || typeof capabilities !== 'object' || Array.isArray(capabilities)) {
+    return {};
+  }
+  return Object.fromEntries(Object.entries(capabilities).map(([key, value]) => [
+    key,
+    typeof value === 'boolean' ? value : value !== 'unsupported' && value != null
+  ]));
+}
+
+function publicResourceTypes(resourceTypes) {
+  if (!resourceTypes || typeof resourceTypes !== 'object' || Array.isArray(resourceTypes)) {
+    return null;
+  }
+  return Object.fromEntries(
+    Object.entries(resourceTypes).filter(([, value]) => typeof value === 'boolean')
+  );
+}
+
+function toPublicDefinition(definition) {
+  if (!definition || typeof definition !== 'object') return null;
+  const result = {};
+  for (const field of PUBLIC_FIELDS) {
+    if (field === 'resourceTypes') {
+      const resourceTypes = publicResourceTypes(definition.resourceTypes);
+      if (resourceTypes) result.resourceTypes = resourceTypes;
+      continue;
+    }
+    if (field === 'apiPrefix') {
+      const apiPrefix = definition.apiPrefix ?? definition.api?.prefix;
+      if (apiPrefix !== undefined) result.apiPrefix = apiPrefix || null;
+      continue;
+    }
+    if (field === 'modelCatalogKey') {
+      result.modelCatalogKey = definition.modelCatalogKey
+        || definition.modelConfig?.catalogKey
+        || definition.key;
+      continue;
+    }
+    if (definition[field] !== undefined) result[field] = definition[field];
+  }
+  result.capabilities = publicCapabilities(definition.capabilities);
+  return result.key ? result : null;
+}
+
+function defaultDependencies() {
+  return require('../platform-context').getPlatformContext();
+}
+
+function createPlatformRouter(options = {}) {
+  let registry = options.registry;
+  let runtime = options.runtime;
+  if (!registry || !runtime) {
+    const defaults = defaultDependencies();
+    registry = registry || defaults.registry;
+    runtime = runtime || defaults.runtime;
+  }
+  const router = express.Router();
+
+  router.get('/', (request, response) => {
+    try {
+      const definitions = typeof registry.list === 'function' ? registry.list() : [];
+      const platforms = definitions.map(toPublicDefinition).filter(Boolean);
+      return response.json({ platforms });
+    } catch (error) {
+      return response.status(500).json({
+        error: {
+          status: 'failed',
+          code: 'failed',
+          operation: 'list-platforms',
+          error: error && error.message ? error.message : String(error)
+        }
+      });
+    }
+  });
+
+  createPlatformRouteFactory({ registry, runtime }).mount(router);
+  return router;
+}
+
+module.exports = createPlatformRouter;
+module.exports.createPlatformRouter = createPlatformRouter;
+module.exports._test = {
+  publicCapabilities,
+  toPublicDefinition
+};

package/src/server/api/plugins.js

@@ -35,7 +35,7 @@ function getPluginsService(req) {
   };
 }
 
-async function getRequestOptions(req) {
+async function getRequestOptions(req, service) {
   const scope = String(req.query?.scope || req.body?.scope || '').trim();
   if (scope && scope !== 'user' && scope !== 'project') {
     throw new Error('Invalid scope: expected "user" or "project"');
@@ -44,10 +44,13 @@ async function getRequestOptions(req) {
   if (scope === 'project' && !cwd) {
     throw new Error('Project scope requires a valid cwd');
   }
-  return {
+  const requestData = {
     ...(cwd ? { cwd } : {}),
     ...(scope ? { scope } : {})
   };
+  return typeof service?.getRequestOptions === 'function'
+    ? service.getRequestOptions(requestData)
+    : requestData;
 }
 
 function extractRepoPayload(source = {}) {
@@ -58,7 +61,7 @@ function extractRepoPayload(source = {}) {
     host: repo.host || source.host || '',
     owner: repo.owner || source.owner || '',
     name: repo.name || source.name || '',
-    branch: repo.branch || source.branch || 'main',
+    branch: repo.branch || source.branch || '',
     directory: repo.directory || source.directory || '',
     projectPath: repo.projectPath || source.projectPath || '',
     localPath: repo.localPath || source.localPath || '',
@@ -86,11 +89,33 @@ function sanitizeRepos(service, repos = []) {
   }
   return (Array.isArray(repos) ? repos : []).map(sanitizeRepo);
 }
+function normalizeInstallMetadata(service, requestBody, repoPayload) {
+  if (typeof service?.normalizeInstallMetadata === 'function') {
+    return service.normalizeInstallMetadata(requestBody, repoPayload);
+  }
+  if (repoPayload) return repoPayload;
+  const metadata = requestBody.metadata && typeof requestBody.metadata === 'object'
+    ? requestBody.metadata
+    : {};
+  if (Object.keys(metadata).length === 0 && !requestBody.pluginId && !requestBody.name) return null;
+  return {
+    ...metadata,
+    name: requestBody.name || metadata.name,
+    pluginId: requestBody.pluginId || metadata.pluginId,
+    pluginKind: requestBody.pluginKind || metadata.pluginKind,
+    marketplace: requestBody.marketplace || metadata.marketplace,
+    installSource: requestBody.installSource || metadata.installSource,
+    version: requestBody.version || metadata.version,
+    description: requestBody.description || metadata.description,
+    resourceTypes: requestBody.resourceTypes || metadata.resourceTypes
+  };
+}
 
-function hasRequestOptions(options = {}) {
-  return Object.keys(options).length > 0;
+function invokeWithOptions(method, args, options) {
+  return Object.keys(options || {}).length > 0 ? method(...args, options) : method(...args);
 }
 
+
 /**
  * 获取平台插件能力
  * GET /api/plugins/capabilities
@@ -120,10 +145,8 @@ router.get('/capabilities', (req, res) => {
 router.get('/', async (req, res) => {
   try {
     const { platform, service, warning } = getPluginsService(req);
-    const options = await getRequestOptions(req);
-    const result = platform === 'omp' || hasRequestOptions(options)
-      ? service.listPlugins(options)
-      : service.listPlugins();
+    const options = await getRequestOptions(req, service);
+    const result = invokeWithOptions(service.listPlugins.bind(service), [], options);
 
     res.json({
       success: true,
@@ -144,14 +167,12 @@ router.get('/', async (req, res) => {
 router.get('/market', async (req, res) => {
   try {
     const { platform, service, warning } = getPluginsService(req);
-    const options = await getRequestOptions(req);
+    const options = await getRequestOptions(req, service);
     const forceRefresh = req.query.refresh === '1';
     if (forceRefresh) {
       console.log(`[Plugins API] Refreshing market plugins for ${platform}...`);
     }
-    const plugins = platform === 'omp' || hasRequestOptions(options)
-      ? await service.getMarketPlugins(forceRefresh, options)
-      : await service.getMarketPlugins(forceRefresh);
+    const plugins = await invokeWithOptions(service.getMarketPlugins.bind(service), [forceRefresh], options);
     console.log(`[Plugins API] ${platform}: ${plugins.length} market plugins loaded (refresh=${forceRefresh})`);
 
     res.json({
@@ -174,7 +195,7 @@ router.get('/market', async (req, res) => {
 router.post('/install', async (req, res) => {
   try {
     const { platform, service, warning } = getPluginsService(req);
-    const options = await getRequestOptions(req);
+    const options = await getRequestOptions(req, service);
     const { directory, repo, gitUrl, source, pluginId } = req.body;
     const hasDirectoryField = Object.prototype.hasOwnProperty.call(req.body, 'directory');
 
@@ -193,25 +214,14 @@ router.post('/install', async (req, res) => {
       });
     }
 
-    const repoMetadata = repo && hasDirectoryField
-      ? {
-          ...extractRepoPayload({ repo }),
-          directory: directory || ''
-        }
-      : platform === 'omp' ? {
-          ...(req.body.metadata && typeof req.body.metadata === 'object' ? req.body.metadata : {}),
-          name: req.body.name || req.body.metadata?.name,
-          pluginId: pluginId || req.body.metadata?.pluginId,
-          pluginKind: req.body.pluginKind || req.body.metadata?.pluginKind,
-          marketplace: req.body.marketplace || req.body.metadata?.marketplace,
-          installSource: req.body.installSource || req.body.metadata?.installSource,
-          version: req.body.version || req.body.metadata?.version,
-          description: req.body.description || req.body.metadata?.description,
-          resourceTypes: req.body.resourceTypes || req.body.metadata?.resourceTypes
-        } : null;
-    const result = platform === 'omp' || hasRequestOptions(options)
-      ? await service.installPlugin(installUrl, repoMetadata, options)
-      : await service.installPlugin(installUrl, repoMetadata);
+    const repoMetadata = normalizeInstallMetadata(
+      service,
+      req.body,
+      repo && hasDirectoryField
+        ? { ...extractRepoPayload({ repo }), directory: directory || '' }
+        : null
+    );
+    const result = await invokeWithOptions(service.installPlugin.bind(service), [installUrl, repoMetadata], options);
 
     if (!result.success) {
       return res.status(400).json({
@@ -242,10 +252,8 @@ router.post('/install', async (req, res) => {
 router.get('/repos', async (req, res) => {
   try {
     const { platform, service, warning } = getPluginsService(req);
-    const options = await getRequestOptions(req);
-    const repos = platform === 'omp' || hasRequestOptions(options)
-      ? service.getRepos(options)
-      : service.getRepos();
+    const options = await getRequestOptions(req, service);
+    const repos = invokeWithOptions(service.getRepos.bind(service), [], options);
     res.json({
       success: true,
       platform,
@@ -271,7 +279,7 @@ router.get('/repos', async (req, res) => {
 router.post('/repos', async (req, res) => {
   try {
     const { platform, service } = getPluginsService(req);
-    const options = await getRequestOptions(req);
+    const options = await getRequestOptions(req, service);
     const repo = extractRepoPayload(req.body);
     repo.enabled = req.body.enabled !== false;
 
@@ -282,9 +290,7 @@ router.post('/repos', async (req, res) => {
       });
     }
 
-    const repos = platform === 'omp' || hasRequestOptions(options)
-      ? service.addRepo(repo, options)
-      : service.addRepo(repo);
+    const repos = invokeWithOptions(service.addRepo.bind(service), [repo], options);
 
     res.json({
       success: true,
@@ -301,11 +307,9 @@ router.post('/repos', async (req, res) => {
 router.delete('/repos', async (req, res) => {
   try {
     const { platform, service } = getPluginsService(req);
-    const options = await getRequestOptions(req);
+    const options = await getRequestOptions(req, service);
     const { id = '', owner = '', name = '' } = req.query;
-    const repos = platform === 'omp' || hasRequestOptions(options)
-      ? service.removeRepo(owner, name, id, options)
-      : service.removeRepo(owner, name, id);
+    const repos = invokeWithOptions(service.removeRepo.bind(service), [owner, name, id], options);
 
     res.json({
       success: true,
@@ -437,7 +441,7 @@ router.put('/repos/auth', (req, res) => {
 router.post('/repos/sync', async (req, res) => {
   try {
     const { platform, service } = getPluginsService(req);
-    const options = await getRequestOptions(req);
+    const options = await getRequestOptions(req, service);
     const result = await service.syncRepos(options);
 
     res.json({
@@ -459,7 +463,7 @@ router.post('/repos/sync', async (req, res) => {
 router.post('/sync', async (req, res) => {
   try {
     const { platform, service } = getPluginsService(req);
-    const options = await getRequestOptions(req);
+    const options = await getRequestOptions(req, service);
     const result = await service.syncPlugins(options);
 
     res.json({
@@ -539,7 +543,7 @@ router.get('/:name', async (req, res) => {
   try {
     const { platform, service } = getPluginsService(req);
     const { name } = req.params;
-    const options = await getRequestOptions(req);
+    const options = await getRequestOptions(req, service);
 
     const plugin = service.getPlugin(req.query.pluginId || name, options);
 
@@ -569,7 +573,7 @@ router.delete('/:name', async (req, res) => {
   try {
     const { platform, service } = getPluginsService(req);
     const { name } = req.params;
-    const options = await getRequestOptions(req);
+    const options = await getRequestOptions(req, service);
     const pluginId = req.query.pluginId || name;
 
     const result = service.uninstallPlugin(pluginId, options);
@@ -602,7 +606,7 @@ router.put('/:name/toggle', async (req, res) => {
     const { platform, service } = getPluginsService(req);
     const { name } = req.params;
     const { enabled, pluginId = name } = req.body;
-    const options = await getRequestOptions(req);
+    const options = await getRequestOptions(req, service);
 
     if (typeof enabled !== 'boolean') {
       return res.status(400).json({
@@ -611,9 +615,7 @@ router.put('/:name/toggle', async (req, res) => {
       });
     }
 
-    const plugin = platform === 'omp' || hasRequestOptions(options)
-      ? service.togglePlugin(pluginId, enabled, options)
-      : service.togglePlugin(pluginId, enabled);
+    const plugin = invokeWithOptions(service.togglePlugin.bind(service), [pluginId, enabled], options);
 
     res.json({
       success: true,
@@ -637,7 +639,7 @@ router.put('/:name/config', async (req, res) => {
     const { platform, service } = getPluginsService(req);
     const { name } = req.params;
     const { config, pluginId = name } = req.body;
-    const options = await getRequestOptions(req);
+    const options = await getRequestOptions(req, service);
 
     if (!config || typeof config !== 'object') {
       return res.status(400).json({
@@ -646,9 +648,7 @@ router.put('/:name/config', async (req, res) => {
       });
     }
 
-    const result = platform === 'omp' || hasRequestOptions(options)
-      ? service.updatePluginConfig(pluginId, config, options)
-      : service.updatePluginConfig(pluginId, config);
+    const result = invokeWithOptions(service.updatePluginConfig.bind(service), [pluginId, config], options);
 
     res.json({
       success: true,