coding-tool-x 3.8.4 → 3.8.5

package/src/server/services/config-registry-service.js

@@ -10,6 +10,11 @@
 const fs = require('fs');
 const path = require('path');
 const { PATHS, NATIVE_PATHS } = require('../../config/paths');
+const { getPlatformContext } = require('../platform-context');
+const { ControlManifestStore } = require('./control-manifest-store');
+const { EffectiveControlService } = require('./effective-control-service');
+const { SkillArtifactStore } = require('./skill-artifact-store');
+const { SkillFormatAdapter } = require('./skill-format-adapters');
 
 // Configuration paths
 const CC_TOOL_DIR = PATHS.base;
@@ -24,33 +29,57 @@ const CLAUDE_DIRS = {
   agents: NATIVE_PATHS.claude.agents || path.join(CLAUDE_HOME_DIR, 'agents'),
   plugins: NATIVE_PATHS.claude.plugins || path.join(CLAUDE_HOME_DIR, 'plugins')
 };
-
 // Valid config types
 const CONFIG_TYPES = ['skills', 'commands', 'agents', 'plugins'];
-const SUPPORTED_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode', 'omp'];
 
-const PLATFORM_SUPPORT = {
-  skills: { claude: true, codex: true, gemini: true, opencode: true, omp: true },
-  commands: { claude: true, codex: true, gemini: true, opencode: true, omp: true },
-  agents: { claude: true, codex: true, gemini: true, opencode: true, omp: false },
-  plugins: { claude: true, codex: false, gemini: false, opencode: true, omp: true }
-};
+function getSupportedPlatforms(registry = getPlatformContext().registry) {
+  if (!registry || typeof registry.list !== 'function') return [];
+  return registry.list()
+    .map(platform => platform && platform.key)
+    .filter(Boolean);
+}
+
+function buildPlatformSupport(registry = getPlatformContext().registry) {
+  const support = Object.fromEntries(CONFIG_TYPES.map(type => [type, {}]));
+  for (const platform of (registry?.list?.() || [])) {
+    const key = platform && platform.key;
+    if (!key) continue;
+    const resourceDriver = platform.capabilities?.resourceSync;
+    for (const type of CONFIG_TYPES) {
+      const typeCapability = platform.capabilities && Object.prototype.hasOwnProperty.call(platform.capabilities, type)
+        ? platform.capabilities[type]
+        : null;
+      const declared = resourceDriver && resourceDriver !== 'unsupported' && typeCapability !== 'unsupported';
+      const typeDeclared = platform.resourceTypes && Object.prototype.hasOwnProperty.call(platform.resourceTypes, type)
+        ? platform.resourceTypes[type]
+        : declared;
+      support[type][key] = declared && typeDeclared !== false;
+    }
+  }
+  return support;
+}
 
 function normalizePlatforms(type, platforms = {}) {
-  const support = PLATFORM_SUPPORT[type] || {};
+  const supportedPlatforms = getSupportedPlatforms();
+  const support = buildPlatformSupport();
   const normalized = {};
 
-  for (const platform of SUPPORTED_PLATFORMS) {
+  for (const platform of supportedPlatforms) {
     normalized[platform] = !!platforms?.[platform];
   }
 
-  for (const platform of SUPPORTED_PLATFORMS) {
-    if (support[platform] === false) {
-      normalized[platform] = false;
+  for (const platform of supportedPlatforms) {
+    if (support[type]?.[platform] === false) normalized[platform] = false;
+  }
+
+  // Preserve historical flags for platforms absent from the current registry.
+  for (const [platform, enabled] of Object.entries(platforms || {})) {
+    if (!Object.prototype.hasOwnProperty.call(normalized, platform)) {
+      normalized[platform] = !!enabled;
     }
   }
 
-  // Default to Claude enabled when no platform explicitly configured
+  // Default to Claude enabled when no platform explicitly configured.
   if (!platforms || Object.keys(platforms).length === 0) {
     normalized.claude = true;
   }
@@ -58,6 +87,8 @@ function normalizePlatforms(type, platforms = {}) {
   return normalized;
 }
 
+const RESERVED_CONFIG_NAMES = new Set(['__proto__', 'constructor', 'prototype']);
+
 function normalizeRelativeConfigName(name) {
   const raw = String(name || '').replace(/\\/g, '/').trim();
   if (!raw || raw.includes('\0')) {
@@ -72,6 +103,9 @@ function normalizeRelativeConfigName(name) {
   if (path.isAbsolute(raw) || raw.startsWith('/')) {
     throw new Error('Absolute path is not allowed');
   }
+  if (RESERVED_CONFIG_NAMES.has(normalized)) {
+    throw new Error('Invalid config name');
+  }
 
   return normalized;
 }
@@ -94,13 +128,67 @@ function ensureDir(dirPath) {
   }
 }
 
+function collectSkillFiles(rootDir) {
+  const files = [];
+  const visit = currentDir => {
+    if (fs.lstatSync(currentDir).isSymbolicLink()) {
+      throw new Error(`Skill artifact contains symlink: ${currentDir}`);
+    }
+    for (const entry of fs.readdirSync(currentDir, { withFileTypes: true })) {
+      const sourcePath = path.join(currentDir, entry.name);
+      if (entry.isSymbolicLink()) {
+        throw new Error(`Skill artifact contains symlink: ${sourcePath}`);
+      }
+      if (entry.isDirectory()) {
+        visit(sourcePath);
+      } else if (entry.isFile()) {
+        files.push({
+          relativePath: path.relative(rootDir, sourcePath).replace(/\\/g, '/'),
+          content: fs.readFileSync(sourcePath)
+        });
+      }
+    }
+  };
+  visit(rootDir);
+  return files;
+}
+
 /**
  * Config Registry Service
  */
 class ConfigRegistryService {
-  constructor() {
+  constructor({ controlService = null, artifactStore = null, formatAdapter = null, registry = getPlatformContext().registry } = {}) {
+    this.registry = registry;
     this.registryPath = REGISTRY_FILE;
     this.configsDir = CONFIGS_DIR;
+    let native = NATIVE_PATHS.claude || {};
+    try {
+      const pathContext = this.registry?.resolvePathContext?.('claude');
+      if (pathContext?.customized) native = pathContext.native || native;
+    } catch {
+      // Keep the compatibility defaults when the registry is unavailable.
+    }
+    const claudeHomeDir = native.dir || path.dirname(native.settings || CLAUDE_HOME_DIR);
+    this.claudeDirs = {
+      skills: native.skills || path.join(claudeHomeDir, 'skills'),
+      commands: native.commands || path.join(claudeHomeDir, 'commands'),
+      agents: native.agents || path.join(claudeHomeDir, 'agents'),
+      plugins: native.plugins || path.join(claudeHomeDir, 'plugins')
+    };
+    this.artifactStore = artifactStore || (
+      PATHS.skillArtifacts ? new SkillArtifactStore({ root: PATHS.skillArtifacts }) : null
+    );
+    this.formatAdapter = formatAdapter || new SkillFormatAdapter();
+    this.controlService = controlService || (
+      PATHS.effectiveControlManifest
+        ? new EffectiveControlService({
+          store: new ControlManifestStore({
+            userPath: PATHS.effectiveControlManifest,
+            projectPathResolver: ({ projectPath }) => path.join(projectPath, '.ctx-control.json')
+          })
+        })
+        : null
+    );
 
     // Ensure directories exist
     this._ensureDirs();
@@ -120,6 +208,141 @@ class ConfigRegistryService {
     }
   }
 
+  migrateSkillControls() {
+    if (!this.controlService) return { migrated: 0, skipped: 0, migrationVersion: 0 };
+    const registry = this._readRegistry();
+    let migrated = 0;
+    let skipped = 0;
+    for (const [name, item] of Object.entries(registry.skills || {})) {
+      let safeName;
+      try {
+        safeName = normalizeRelativeConfigName(name);
+      } catch {
+        skipped++;
+        continue;
+      }
+      if (!item || typeof item !== 'object') continue;
+      const platforms = Object.keys(item.platforms || {});
+      for (const platform of platforms.length > 0 ? platforms : ['claude']) {
+        const sourceKey = `local:${platform}:${safeName}`;
+        const controlKey = `skill:${platform}:user:user:${sourceKey}`;
+        if (this.controlService.getSkill(controlKey, { scope: 'user' })) {
+          skipped++;
+          continue;
+        }
+
+        const legacyRoot = path.join(this.configsDir, 'skills', safeName);
+        const legacySkillPath = path.join(legacyRoot, 'SKILL.md');
+        const legacyReady = fs.existsSync(legacySkillPath);
+        let artifactRoot = legacyReady ? legacyRoot : null;
+        let artifactFormat = null;
+        let artifactHash = null;
+        let artifactState = legacyReady ? 'ready' : 'metadata_only';
+        let lastError = null;
+
+        if (legacyReady && this.artifactStore) {
+          try {
+            const normalized = this.formatAdapter.normalize({
+              platform,
+              files: collectSkillFiles(legacyRoot),
+              sourceMetadata: { name: safeName }
+            });
+            const published = this.artifactStore.publishSkill({
+              platform,
+              sourceKey,
+              format: normalized.format,
+              files: normalized.files,
+              metadata: {
+                name: safeName,
+                directory: safeName,
+                sourceProvider: 'local',
+                sourceScope: 'user',
+                revision: null
+              }
+            });
+            artifactRoot = published.root;
+            artifactFormat = published.format || normalized.format;
+            artifactHash = published.contentHash || null;
+            artifactState = published.state || 'ready';
+          } catch (error) {
+            artifactRoot = null;
+            artifactState = 'missing';
+            lastError = error.message;
+          }
+        }
+
+        const platformEnabled = platforms.length === 0
+          ? platform === 'claude'
+          : item.platforms?.[platform] === true;
+        const enabled = artifactState !== 'metadata_only'
+          && artifactState !== 'missing'
+          && item.enabled !== false
+          && platformEnabled;
+        const registered = this.controlService.registerSkill({
+          kind: 'skill',
+          controlKey,
+          platform,
+          scope: 'user',
+          projectPath: null,
+          sourceKey,
+          source: {
+            kind: 'local',
+            repoId: null,
+            fullDirectory: safeName,
+            revision: null
+          },
+          artifact: {
+            root: artifactRoot,
+            format: artifactFormat,
+            contentHash: artifactHash,
+            state: artifactState,
+            fetchedAt: null
+          },
+          targetDirectory: safeName,
+          cached: Boolean(artifactRoot) && artifactState !== 'missing',
+          enabled,
+          trust: enabled ? 'approved' : (artifactState === 'missing' ? 'needs_review' : 'pending'),
+          projection: {
+            mode: 'native-copy',
+            state: enabled ? 'enabled' : 'disabled',
+            sourceKey,
+            path: null,
+            updatedAt: null
+          },
+          managed: true,
+          lastError,
+          createdAt: Date.now(),
+          updatedAt: Date.now()
+        });
+        if (!enabled && this.controlService.setSkillEnabled) {
+          try {
+            this.controlService.setSkillEnabled({
+              platform,
+              controlKey: registered.controlKey,
+              scope: 'user',
+              projectPath: null,
+              enabled: false
+            });
+          } catch (error) {
+            console.warn(`[ConfigRegistry] Failed to disable migrated Skill ${safeName}:`, error.message);
+          }
+        }
+        migrated++;
+      }
+    }
+
+    const store = this.controlService.store;
+    if (store?.read && store?.write) {
+      const scope = { scope: 'user', projectPath: null };
+      const manifest = store.read(scope);
+      if (manifest.migrationVersion !== 1) {
+        manifest.migrationVersion = 1;
+        store.write(scope, manifest);
+      }
+    }
+    return { migrated, skipped, migrationVersion: 1 };
+  }
+
   /**
    * Read registry from file
    * @returns {Object} Registry data
@@ -180,9 +403,11 @@ class ConfigRegistryService {
     if (!CONFIG_TYPES.includes(type)) {
       throw new Error(`Invalid config type: ${type}`);
     }
-
+    const safeName = normalizeRelativeConfigName(name);
     const registry = this._readRegistry();
-    return registry[type][name] || null;
+    return Object.prototype.hasOwnProperty.call(registry[type], safeName)
+      ? registry[type][safeName]
+      : null;
   }
 
   /**
@@ -190,17 +415,18 @@ class ConfigRegistryService {
    * @param {string} type - Config type
    * @param {string} name - Item name/key
    * @param {Object} data - Item data
-   * @returns {Object} Updated entry
    */
   setItem(type, name, data) {
     if (!CONFIG_TYPES.includes(type)) {
       throw new Error(`Invalid config type: ${type}`);
     }
-
+    const safeName = normalizeRelativeConfigName(name);
     const registry = this._readRegistry();
     const now = new Date().toISOString();
 
-    const existing = registry[type][name];
+    const existing = Object.prototype.hasOwnProperty.call(registry[type], safeName)
+      ? registry[type][safeName]
+      : null;
     const entry = {
       ...data,
       enabled: data.enabled !== undefined ? data.enabled : true,
@@ -210,7 +436,7 @@ class ConfigRegistryService {
       source: data.source || 'local'
     };
 
-    registry[type][name] = entry;
+    registry[type][safeName] = entry;
     this._writeRegistry(registry);
 
     return entry;
@@ -226,18 +452,18 @@ class ConfigRegistryService {
     if (!CONFIG_TYPES.includes(type)) {
       throw new Error(`Invalid config type: ${type}`);
     }
-
+    const safeName = normalizeRelativeConfigName(name);
     const registry = this._readRegistry();
 
-    if (!registry[type][name]) {
+    if (!Object.prototype.hasOwnProperty.call(registry[type], safeName)) {
       return false;
     }
 
-    delete registry[type][name];
+    delete registry[type][safeName];
     this._writeRegistry(registry);
 
     // Also remove the actual config files
-    const configPath = this.getConfigPath(type, name);
+    const configPath = this.getConfigPath(type, safeName);
     if (fs.existsSync(configPath)) {
       try {
         const stats = fs.statSync(configPath);
@@ -247,7 +473,7 @@ class ConfigRegistryService {
           fs.unlinkSync(configPath);
         }
       } catch (err) {
-        console.error(`[ConfigRegistry] Failed to remove config files for ${type}/${name}:`, err.message);
+        console.error(`[ConfigRegistry] Failed to remove config files for ${type}/${safeName}:`, err.message);
       }
     }
 
@@ -279,9 +505,11 @@ class ConfigRegistryService {
     if (!CONFIG_TYPES.includes(type)) {
       throw new Error(`Invalid config type: ${type}`);
     }
-
+    const safeName = normalizeRelativeConfigName(name);
     const registry = this._readRegistry();
-    const entry = registry[type][name];
+    const entry = Object.prototype.hasOwnProperty.call(registry[type], safeName)
+      ? registry[type][safeName]
+      : null;
 
     if (!entry) {
       throw new Error(`Item "${name}" not found in ${type}`);
@@ -301,23 +529,25 @@ class ConfigRegistryService {
    * @param {string} name - Item name/key
    * @param {string} platform - Platform name (claude, codex, gemini, opencode)
    * @param {boolean} enabled - New platform status
-   * @returns {Object} Updated entry
    */
   togglePlatform(type, name, platform, enabled) {
     if (!CONFIG_TYPES.includes(type)) {
       throw new Error(`Invalid config type: ${type}`);
     }
 
-    if (!SUPPORTED_PLATFORMS.includes(platform)) {
+    if (!getSupportedPlatforms().includes(platform)) {
       throw new Error(`Invalid platform: ${platform}`);
     }
 
-    if (PLATFORM_SUPPORT[type] && PLATFORM_SUPPORT[type][platform] === false) {
+    if (buildPlatformSupport()[type]?.[platform] === false) {
       throw new Error(`Platform "${platform}" is not supported for ${type}`);
     }
 
+    const safeName = normalizeRelativeConfigName(name);
     const registry = this._readRegistry();
-    const entry = registry[type][name];
+    const entry = Object.prototype.hasOwnProperty.call(registry[type], safeName)
+      ? registry[type][safeName]
+      : null;
 
     if (!entry) {
       throw new Error(`Item "${name}" not found in ${type}`);
@@ -345,7 +575,7 @@ class ConfigRegistryService {
       throw new Error(`Invalid config type: ${type}`);
     }
 
-    const sourceDir = CLAUDE_DIRS[type];
+    const sourceDir = this.claudeDirs[type];
     const destDir = path.join(this.configsDir, type);
 
     if (!fs.existsSync(sourceDir)) {
@@ -555,6 +785,9 @@ class ConfigRegistryService {
    * @private
    */
   _copyDirRecursive(src, dest) {
+    if (fs.lstatSync(src).isSymbolicLink()) {
+      throw new Error(`Config source contains symlink: ${src}`);
+    }
     ensureDir(dest);
 
     const entries = fs.readdirSync(src, { withFileTypes: true });
@@ -562,10 +795,12 @@ class ConfigRegistryService {
     for (const entry of entries) {
       const srcPath = path.join(src, entry.name);
       const destPath = path.join(dest, entry.name);
-
+      if (entry.isSymbolicLink()) {
+        throw new Error(`Config source contains symlink: ${srcPath}`);
+      }
       if (entry.isDirectory()) {
         this._copyDirRecursive(srcPath, destPath);
-      } else {
+      } else if (entry.isFile()) {
         fs.copyFileSync(srcPath, destPath);
       }
     }
@@ -577,16 +812,11 @@ class ConfigRegistryService {
    */
   getStats() {
     const registry = this._readRegistry();
+    const supportedPlatforms = getSupportedPlatforms();
     const stats = {
       total: 0,
       byType: {},
-      byPlatform: {
-        claude: 0,
-        codex: 0,
-        gemini: 0,
-        opencode: 0,
-        omp: 0
-      }
+      byPlatform: Object.fromEntries(supportedPlatforms.map(platform => [platform, 0]))
     };
 
     for (const type of CONFIG_TYPES) {
@@ -594,21 +824,16 @@ class ConfigRegistryService {
       const typeStats = {
         total: items.length,
         enabled: items.filter(i => i.enabled).length,
-        disabled: items.filter(i => !i.enabled).length,
-        claude: items.filter(i => i.platforms?.claude).length,
-        codex: items.filter(i => i.platforms?.codex).length,
-        gemini: items.filter(i => i.platforms?.gemini).length,
-        opencode: items.filter(i => i.platforms?.opencode).length,
-        omp: items.filter(i => i.platforms?.omp).length
+        disabled: items.filter(i => !i.enabled).length
       };
 
+      for (const platform of supportedPlatforms) {
+        typeStats[platform] = items.filter(item => item.platforms?.[platform]).length;
+        stats.byPlatform[platform] += typeStats[platform];
+      }
+
       stats.byType[type] = typeStats;
       stats.total += typeStats.total;
-      stats.byPlatform.claude += typeStats.claude;
-      stats.byPlatform.codex += typeStats.codex;
-      stats.byPlatform.gemini += typeStats.gemini;
-      stats.byPlatform.opencode += typeStats.opencode;
-      stats.byPlatform.omp += typeStats.omp;
     }
 
     return stats;
@@ -826,7 +1051,8 @@ class ConfigRegistryService {
 module.exports = {
   ConfigRegistryService,
   CONFIG_TYPES,
-  SUPPORTED_PLATFORMS,
+  getSupportedPlatforms,
+  buildPlatformSupport,
   CONFIGS_DIR,
   REGISTRY_FILE
 };