coding-tool-x 3.6.13 → 3.7.1

package/src/server/services/plugins-service.js

@@ -12,12 +12,14 @@ const path = require('path');
 const { execFileSync } = require('child_process');
 const toml = require('toml');
 const tomlStringify = require('@iarna/toml').stringify;
+const yaml = require('js-yaml');
 const AdmZip = require('adm-zip');
 const { listPlugins, getPlugin, updatePlugin: updatePluginRegistry } = require('../../plugins/registry');
 const { installPlugin: installPluginCore, uninstallPlugin: uninstallPluginCore } = require('../../plugins/plugin-installer');
 const { initializePlugins, shutdownPlugins } = require('../../plugins/plugin-manager');
 const { INSTALLED_DIR, CONFIG_DIR } = require('../../plugins/constants');
 const { NATIVE_PATHS, PATHS } = require('../../config/paths');
+const { getOmpCommand } = require('./omp-config');
 const { maskToken } = require('./oauth-utils');
 const {
   assertInsideAllowedRoots,
@@ -26,7 +28,8 @@ const {
   resolveInsideRoot
 } = require('./config-artifact-paths');
 
-const CLAUDE_PLUGINS_DIR = path.join(path.dirname(NATIVE_PATHS.claude.settings), 'plugins');
+const CLAUDE_PLUGINS_DIR = NATIVE_PATHS.claude.plugins
+  || path.join(NATIVE_PATHS.claude.dir || path.dirname(NATIVE_PATHS.claude.settings), 'plugins');
 const CLAUDE_INSTALLED_FILE = path.join(CLAUDE_PLUGINS_DIR, 'installed_plugins.json');
 const CLAUDE_MARKETPLACES_FILE = path.join(CLAUDE_PLUGINS_DIR, 'known_marketplaces.json');
 const CLAUDE_PLUGINS_CACHE_DIR = path.join(CLAUDE_PLUGINS_DIR, 'cache');
@@ -42,9 +45,10 @@ const DEFAULT_REPOS_BY_PLATFORM = {
   claude: [],
   codex: [],
   gemini: [],
-  opencode: []
+  opencode: [],
+  omp: []
 };
-const SUPPORTED_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode'];
+const SUPPORTED_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode', 'omp'];
 const PLATFORM_CAPABILITIES = {
   claude: {
     platform: 'claude',
@@ -94,6 +98,19 @@ const PLATFORM_CAPABILITIES = {
     config: true,
     import: false,
     syncRepos: false
+  },
+  omp: {
+    platform: 'omp',
+    supportsPlugins: true,
+    repositories: true,
+    market: true,
+    install: true,
+    uninstall: true,
+    toggle: true,
+    config: true,
+    import: false,
+    syncRepos: false,
+    pluginKindLabel: 'packages/extensions'
   }
 };
 
@@ -177,6 +194,134 @@ function splitPluginMarketplaceKey(key = '') {
   };
 }
 
+function normalizeOmpPackageEntry(item = null) {
+  if (typeof item === 'string') {
+    const name = item.trim();
+    return name ? {
+      name,
+      source: name,
+      directory: name,
+      installSource: name,
+      resourceTypes: []
+    } : null;
+  }
+  if (!item || typeof item !== 'object') return null;
+
+  const rawName = item.name || item.package || item.id || item.source || item.path || '';
+  const name = String(rawName || '').trim();
+  if (!name) return null;
+
+  const directory = String(item.directory || item.path || name).trim() || name;
+  const installSource = String(item.installSource || item.source || item.url || item.packageSource || name).trim() || name;
+  return {
+    ...item,
+    name,
+    source: item.source || installSource,
+    directory,
+    installSource,
+    resourceTypes: normalizeOmpResourceTypes(item.resourceTypes || item.resources || item.provides || item.capabilities)
+  };
+}
+
+function getOmpPackageIdentity(item = null) {
+  const normalized = normalizeOmpPackageEntry(item);
+  return normalized?.name || '';
+}
+
+function ompPackageSettingValue(item = null) {
+  const normalized = normalizeOmpPackageEntry(item);
+  if (!normalized) return null;
+  if (typeof item === 'string') return normalized.name;
+
+  const next = { ...item };
+  next.name = normalized.name;
+  next.directory = normalized.directory;
+  next.source = normalized.installSource;
+  const resourceTypes = normalizeOmpResourceTypes(next.resourceTypes || next.resources || normalized.resourceTypes);
+  if (resourceTypes.length > 0) {
+    next.resourceTypes = resourceTypes;
+  } else {
+    delete next.resourceTypes;
+  }
+  return next;
+}
+
+function normalizeOmpResourceType(value = '') {
+  const normalized = String(value || '').trim();
+  if (!normalized) return '';
+  const key = normalized
+    .replace(/[\s_-]+/g, '')
+    .toLowerCase();
+  const map = {
+    extension: 'extension',
+    extensions: 'extension',
+    plugin: 'extension',
+    plugins: 'extension',
+    skill: 'skill',
+    skills: 'skill',
+    prompt: 'promptTemplate',
+    prompts: 'promptTemplate',
+    prompttemplate: 'promptTemplate',
+    prompttemplates: 'promptTemplate',
+    prompttemplating: 'promptTemplate',
+    command: 'promptTemplate',
+    commands: 'promptTemplate',
+    theme: 'theme',
+    themes: 'theme',
+    mcp: 'mcp',
+    subagent: 'subagent',
+    subagents: 'subagent',
+    agent: 'subagent',
+    agents: 'subagent'
+  };
+  return map[key] || normalized;
+}
+
+function normalizeOmpResourceTypes(input = []) {
+  const values = [];
+  const pushValue = (value) => {
+    const normalized = normalizeOmpResourceType(value);
+    if (normalized && !values.includes(normalized)) values.push(normalized);
+  };
+
+  if (Array.isArray(input)) {
+    input.forEach(pushValue);
+  } else if (input && typeof input === 'object') {
+    for (const [key, value] of Object.entries(input)) {
+      if (value === false || value == null) continue;
+      if (Array.isArray(value)) {
+        if (value.length > 0) pushValue(key);
+      } else if (typeof value === 'object') {
+        if (Object.keys(value).length > 0) pushValue(key);
+      } else {
+        pushValue(key);
+      }
+    }
+  } else if (input) {
+    pushValue(input);
+  }
+
+  return values;
+}
+
+function isOmpPackageInstallSource(value = '') {
+  const source = String(value || '').trim();
+  if (!source) return false;
+  if (isLikelyLocalPath(source)) return true;
+  if (/^(npm|git):/i.test(source)) return true;
+  if (/^https?:\/\//i.test(source)) return true;
+  if (/^ssh:\/\//i.test(source)) return true;
+  if (/^git@[^:]+:.+/i.test(source)) return true;
+  return !source.startsWith('-');
+}
+
+function normalizeMarketplaceSkillPaths(skills = []) {
+  if (!Array.isArray(skills)) return [];
+  return skills
+    .map(skill => normalizeRepoPath(String(skill || '').replace(/^\.\//, '')))
+    .filter(Boolean);
+}
+
 function hasRepoInstallInfo(repoInfo = null) {
   return Boolean(
     repoInfo &&
@@ -544,11 +689,14 @@ class PluginsService {
         plugin.repoId || '',
         plugin.repoProvider || '',
         plugin.repoOwner || '',
-        plugin.repoName || '',
-        plugin.repoProjectPath || '',
-        plugin.repoLocalPath || '',
-        plugin.directory || plugin.installSource || ''
-      ].join('::');
+      plugin.repoName || '',
+      plugin.repoProjectPath || '',
+      plugin.repoLocalPath || '',
+      plugin.directory || '',
+      plugin.installSource || '',
+      plugin.pluginKind || '',
+      plugin.marketplaceFormat || ''
+    ].join('::');
       if (seen.has(key)) continue;
       seen.add(key);
       deduped.push({
@@ -571,6 +719,10 @@ class PluginsService {
     return this.platform === 'opencode';
   }
 
+  _isOmp() {
+    return this.platform === 'omp';
+  }
+
   _isCodex() {
     return this.platform === 'codex';
   }
@@ -596,6 +748,194 @@ class PluginsService {
     return json;
   }
 
+  _readOmpSettings() {
+    const filePath = NATIVE_PATHS.omp.settings;
+    if (!fs.existsSync(filePath)) {
+      const legacyPath = NATIVE_PATHS.omp.settingsJsonLegacy;
+      if (legacyPath && fs.existsSync(legacyPath)) {
+        try {
+          const raw = fs.readFileSync(legacyPath, 'utf8');
+          return raw.trim() ? JSON.parse(raw) : {};
+        } catch (err) {
+          console.error('[PluginsService] Failed to read legacy OMP settings:', err.message);
+        }
+      }
+      return {};
+    }
+
+    try {
+      const raw = fs.readFileSync(filePath, 'utf8');
+      const parsed = raw.trim() ? yaml.load(raw) : {};
+      return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    } catch (err) {
+      console.error('[PluginsService] Failed to read OMP settings:', err.message);
+      return {};
+    }
+  }
+
+  _writeOmpSettings(settings = {}) {
+    this._ensureDir(path.dirname(NATIVE_PATHS.omp.settings));
+    fs.writeFileSync(NATIVE_PATHS.omp.settings, yaml.dump(settings, {
+      lineWidth: 120,
+      noRefs: true,
+      sortKeys: false
+    }), 'utf8');
+  }
+
+  _listOmpPackages() {
+    const settings = this._readOmpSettings();
+    return Array.isArray(settings.packages)
+      ? settings.packages.map(normalizeOmpPackageEntry).filter(Boolean)
+      : [];
+  }
+
+  _setOmpPackages(packages = []) {
+    const settings = this._readOmpSettings();
+    const seen = new Set();
+    settings.packages = packages
+      .map(item => ompPackageSettingValue(item))
+      .filter((item) => {
+        const name = getOmpPackageIdentity(item);
+        if (!name || seen.has(name)) return false;
+        seen.add(name);
+        return true;
+      });
+    this._writeOmpSettings(settings);
+  }
+
+  _listOmpDisabledPackageEntries() {
+    const settings = this._readOmpSettings();
+    return Array.isArray(settings.disabledPackages)
+      ? settings.disabledPackages.map(normalizeOmpPackageEntry).filter(Boolean)
+      : [];
+  }
+
+  _listOmpDisabledPackages() {
+    return this._listOmpDisabledPackageEntries().map(item => item.name).filter(Boolean);
+  }
+
+  _setOmpDisabledPackages(packages = []) {
+    const settings = this._readOmpSettings();
+    const seen = new Set();
+    settings.disabledPackages = packages
+      .map(item => ompPackageSettingValue(item))
+      .filter((item) => {
+        const name = getOmpPackageIdentity(item);
+        if (!name || seen.has(name)) return false;
+        seen.add(name);
+        return true;
+      });
+    this._writeOmpSettings(settings);
+  }
+
+  _runOmpPackageCommand(args = []) {
+    execFileSync(getOmpCommand(), args, {
+      cwd: process.cwd(),
+      encoding: 'utf8',
+      stdio: 'pipe',
+      timeout: 120000
+    });
+  }
+
+  _registerOmpPackageReference(packageName, metadata = {}) {
+    const packages = this._listOmpPackages();
+    const installSource = String(metadata.installSource || metadata.source || packageName || '').trim();
+    const displayName = String(metadata.name || packageName || installSource).trim();
+    if (!packages.some(pkg => pkg.name === displayName || pkg.installSource === installSource)) {
+      const resourceTypes = normalizeOmpResourceTypes(metadata.resourceTypes || metadata.resources);
+      const entry = installSource && installSource !== displayName
+        ? {
+            name: displayName,
+            source: installSource,
+            ...(metadata.version ? { version: metadata.version } : {}),
+            ...(metadata.description ? { description: metadata.description } : {}),
+            ...(resourceTypes.length > 0 ? { resourceTypes } : {})
+          }
+        : displayName;
+      packages.push(entry);
+      this._setOmpPackages(packages);
+    }
+  }
+
+  _buildOmpPackagePlugin(packageName, metadata = {}) {
+    const installSource = String(metadata.installSource || metadata.source || packageName || '').trim();
+    const name = String(metadata.name || packageName || installSource).trim();
+    const resourceTypes = normalizeOmpResourceTypes(metadata.resourceTypes || metadata.resources);
+    return {
+      name,
+      directory: name,
+      installSource: installSource || name,
+      version: metadata.version || 'latest',
+      description: metadata.description || '',
+      pluginKind: 'package',
+      pluginType: 'package',
+      ...(resourceTypes.length > 0 ? { resourceTypes } : {})
+    };
+  }
+
+  _installOmpPackage(packageName, metadata = {}) {
+    const installSource = String(metadata.installSource || metadata.source || packageName || '').trim();
+    const plugin = this._buildOmpPackagePlugin(packageName, { ...metadata, installSource });
+    try {
+      this._runOmpPackageCommand(['install', installSource || packageName]);
+      return {
+        success: true,
+        plugin
+      };
+    } catch (err) {
+      this._registerOmpPackageReference(packageName, { ...metadata, installSource, name: plugin.name });
+      return {
+        success: true,
+        registeredOnly: true,
+        warning: `Failed to run "${getOmpCommand()} install"; saved the package reference so OMP can resolve it later. ${err.message}`,
+        plugin
+      };
+    }
+  }
+
+  _removeOmpPackage(packageName) {
+    try {
+      this._runOmpPackageCommand(['remove', packageName]);
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+
+  _listOmpLocalExtensions() {
+    const plugins = [];
+    const extensionsDir = NATIVE_PATHS.omp.extensions;
+    if (!fs.existsSync(extensionsDir)) return plugins;
+
+    try {
+      const disabled = new Set(this._listOmpDisabledPackages());
+      const entries = fs.readdirSync(extensionsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith('.')) continue;
+        const fullPath = path.join(extensionsDir, entry.name);
+        const ext = path.extname(entry.name).toLowerCase();
+        if (!entry.isDirectory() && !['.js', '.mjs', '.cjs', '.ts'].includes(ext)) continue;
+        const name = entry.isDirectory() ? entry.name : entry.name.slice(0, -ext.length);
+        plugins.push({
+          name,
+          directory: entry.name,
+          installPath: fullPath,
+          source: 'omp-extension',
+          version: 'local',
+          description: '',
+          installed: true,
+          enabled: !disabled.has(name) && !disabled.has(entry.name),
+          pluginType: entry.isDirectory() ? 'extension-directory' : 'extension-file',
+          pluginKind: 'extension'
+        });
+      }
+    } catch (err) {
+      console.error('[PluginsService] Failed to list OMP extensions:', err.message);
+    }
+
+    return plugins;
+  }
+
   _readOpenCodeConfig() {
     const filePath = this._getOpenCodeConfigPath();
     if (!fs.existsSync(filePath)) return { filePath, config: {} };
@@ -1112,6 +1452,41 @@ class PluginsService {
       return { plugins };
     }
 
+    if (this._isOmp()) {
+      const disabledEntries = this._listOmpDisabledPackageEntries();
+      const disabled = new Set(disabledEntries.flatMap(item => [item.name, item.installSource].filter(Boolean)));
+      const plugins = [];
+      const seen = new Set();
+
+      for (const pkg of this._listOmpPackages()) {
+        const seenKey = pkg.installSource || pkg.name;
+        if (seen.has(seenKey)) continue;
+        seen.add(seenKey);
+        plugins.push({
+          ...pkg,
+          name: pkg.name,
+          directory: pkg.directory || pkg.name,
+          installSource: pkg.installSource || pkg.source || pkg.name,
+          resourceTypes: normalizeOmpResourceTypes(pkg.resourceTypes || pkg.resources),
+          source: 'omp-settings',
+          version: pkg.version || 'latest',
+          description: pkg.description || '',
+          installed: true,
+          enabled: !disabled.has(pkg.name) && !disabled.has(pkg.installSource),
+          pluginType: 'package',
+          pluginKind: 'package'
+        });
+      }
+
+      for (const extension of this._listOmpLocalExtensions()) {
+        if (seen.has(extension.name)) continue;
+        seen.add(extension.name);
+        plugins.push(extension);
+      }
+
+      return { plugins };
+    }
+
     const plugins = [];
 
     // Read Claude Code's installed_plugins.json
@@ -1251,6 +1626,12 @@ class PluginsService {
       return plugin;
     }
 
+    if (this._isOmp()) {
+      const plugin = this.listPlugins().plugins.find(p => p.name === name || p.directory === name);
+      if (!plugin) return null;
+      return plugin;
+    }
+
     const plugin = getPlugin(name);
     if (!plugin) {
       return null;
@@ -1314,6 +1695,51 @@ class PluginsService {
       };
     }
 
+    if (this._isOmp()) {
+      const packageMetadata = repoInfo && typeof repoInfo === 'object'
+        ? {
+            name: repoInfo.name || repoInfo.packageName || repoInfo.displayName,
+            version: repoInfo.version,
+            description: repoInfo.description,
+            resourceTypes: repoInfo.resourceTypes || repoInfo.resources,
+            installSource: repoInfo.installSource || repoInfo.source
+          }
+        : {};
+      const explicitPackageSource = String(source || packageMetadata.installSource || '').trim();
+
+      if (
+        repoInfo?.pluginKind === 'package' ||
+        repoInfo?.pluginType === 'package' ||
+        (explicitPackageSource && isOmpPackageInstallSource(explicitPackageSource) && !hasRepoInstallInfo(repoInfo))
+      ) {
+        return this._installOmpPackage(explicitPackageSource, packageMetadata);
+      }
+
+      if (hasRepoInstallInfo(repoInfo)) {
+        return this._installFromRepoDirectory(repoInfo, { installRoot: NATIVE_PATHS.omp.extensions });
+      }
+
+      const parsedSource = this.parseRepoTreeSource(source);
+      if (parsedSource) {
+        return this._installOmpPackage(source);
+      }
+
+      const parsedRepo = this._repoFromGitUrl(source, 'main');
+      if (parsedRepo) {
+        return this._installOmpPackage(source);
+      }
+
+      const packageName = String(source || '').trim();
+      if (packageName && isOmpPackageInstallSource(packageName)) {
+        return this._installOmpPackage(packageName);
+      }
+
+      return {
+        success: false,
+        error: 'OMP plugin install expects package name, repository metadata, a GitHub/GitLab tree URL, or a Git repository URL'
+      };
+    }
+
     if (this._isOpenCode()) {
       if (hasRepoInstallInfo(repoInfo)) {
         return this._installFromRepoDirectory(repoInfo, { installRoot: this._getOpenCodePluginsDir() });
@@ -1552,7 +1978,7 @@ class PluginsService {
         } catch (e) {
           console.error('[PluginsService] Failed to update native installed_plugins.json:', e.message);
         }
-      } else if (!this._isOpenCode()) {
+      } else if (!this._isOpenCode() && !this._isOmp()) {
         const installTimestamp = new Date().toISOString();
         const sourceUrl = this.buildRepoBrowserUrl(normalizedRepo, directory) || buildRepoUrl(normalizedRepo);
         const repoSourceMeta = {
@@ -1582,6 +2008,21 @@ class PluginsService {
         }
 
         this.writeRepoSourceMeta(pluginDir, repoSourceMeta);
+      } else if (this._isOmp()) {
+        const sourceUrl = this.buildRepoBrowserUrl(normalizedRepo, directory) || buildRepoUrl(normalizedRepo);
+        this.writeRepoSourceMeta(pluginDir, {
+          repoId: normalizedRepo.id,
+          repoProvider: normalizedRepo.provider,
+          repoOwner: normalizedRepo.owner || '',
+          repoName: normalizedRepo.name || '',
+          repoBranch: normalizedRepo.branch,
+          repoDirectory: directory,
+          repoHost: normalizedRepo.host || '',
+          repoProjectPath: normalizedRepo.projectPath || '',
+          repoLocalPath: normalizedRepo.localPath || '',
+          repoUrl: normalizedRepo.repoUrl || buildRepoUrl(normalizedRepo),
+          source: sourceUrl
+        });
       }
 
       return {
@@ -1607,6 +2048,9 @@ class PluginsService {
     if (this._isOpenCode()) {
       return ['package.json', 'plugin.json'];
     }
+    if (this._isOmp()) {
+      return ['omp.json', 'extension.json', 'plugin.json', 'package.json'];
+    }
     return ['.claude-plugin/plugin.json', 'plugin.json', 'package.json'];
   }
 
@@ -1738,6 +2182,71 @@ class PluginsService {
       };
     }
 
+    if (this._isOmp()) {
+      const targetName = String(name || '').trim();
+      let safeName = '';
+      try {
+        safeName = normalizePluginPathName(targetName, 'plugin name');
+      } catch {
+        safeName = '';
+      }
+      const packages = this._listOmpPackages();
+      let removed = false;
+      const packageToRemove = packages.find(pkg =>
+        pkg.name === targetName ||
+        pkg.name === safeName ||
+        pkg.installSource === targetName ||
+        pkg.installSource === safeName
+      );
+      if (packageToRemove) {
+        this._removeOmpPackage(packageToRemove.installSource || packageToRemove.name);
+      }
+      const nextPackages = packages.filter(pkg =>
+        pkg.name !== safeName &&
+        pkg.name !== targetName &&
+        pkg.installSource !== safeName &&
+        pkg.installSource !== targetName
+      );
+      if (nextPackages.length !== packages.length) {
+        this._setOmpPackages(nextPackages);
+        const disabledEntries = this._listOmpDisabledPackageEntries().filter(pkg =>
+          pkg.name !== safeName &&
+          pkg.name !== targetName &&
+          pkg.installSource !== safeName &&
+          pkg.installSource !== targetName &&
+          pkg.name !== packageToRemove?.name &&
+          pkg.installSource !== packageToRemove?.installSource
+        );
+        this._setOmpDisabledPackages(disabledEntries);
+        removed = true;
+      }
+
+      const extensionsDir = NATIVE_PATHS.omp.extensions;
+      if (safeName && fs.existsSync(extensionsDir)) {
+        const directPath = resolveInsideRoot(extensionsDir, safeName, 'OMP extension path');
+        if (fs.existsSync(directPath)) {
+          fs.rmSync(directPath, { recursive: true, force: true });
+          removed = true;
+        } else {
+          const entries = fs.readdirSync(extensionsDir, { withFileTypes: true });
+          for (const entry of entries) {
+            const baseName = entry.name.replace(path.extname(entry.name), '');
+            if (entry.name === safeName || baseName === safeName) {
+              const entryPath = resolveInsideRoot(extensionsDir, entry.name, 'OMP extension path');
+              fs.rmSync(entryPath, { recursive: true, force: true });
+              removed = true;
+              break;
+            }
+          }
+        }
+      }
+
+      return {
+        success: true,
+        message: removed ? 'Plugin removed successfully' : 'Plugin not found'
+      };
+    }
+
     if (this._isOpenCode()) {
       const safeName = normalizePluginPathName(name, 'plugin name');
       const pluginsDir = this._getOpenCodePluginsDir();
@@ -1870,6 +2379,29 @@ class PluginsService {
       throw new Error(`${this.platform} plugin management is not supported`);
     }
 
+    if (this._isOmp()) {
+      const targetName = String(name || '').trim();
+      const packages = this._listOmpPackages();
+      const targetPackage = packages.find(pkg => pkg.name === targetName || pkg.installSource === targetName);
+      const disabledEntries = this._listOmpDisabledPackageEntries();
+      const disabled = new Set(disabledEntries.flatMap(item => [item.name, item.installSource].filter(Boolean)));
+      if (enabled) {
+        disabled.delete(targetName);
+        if (targetPackage) {
+          disabled.delete(targetPackage.name);
+          disabled.delete(targetPackage.installSource);
+        }
+      } else {
+        disabled.add(targetPackage || targetName);
+      }
+      this._setOmpDisabledPackages(Array.from(disabled));
+      return {
+        name: targetName,
+        enabled,
+        success: true
+      };
+    }
+
     if (this._isOpenCode()) {
       const configured = this._listOpenCodeConfiguredPlugins();
       const exists = configured.includes(name);
@@ -1963,6 +2495,19 @@ class PluginsService {
       throw new Error(`${this.platform} plugin management is not supported`);
     }
 
+    if (this._isOmp()) {
+      const settings = this._readOmpSettings();
+      settings.packageConfig = settings.packageConfig && typeof settings.packageConfig === 'object' && !Array.isArray(settings.packageConfig)
+        ? settings.packageConfig
+        : {};
+      settings.packageConfig[name] = config;
+      this._writeOmpSettings(settings);
+      return {
+        success: true,
+        message: `Configuration updated for plugin "${name}"`
+      };
+    }
+
     if (this._isOpenCode()) {
       const configDir = path.join(OPENCODE_CONFIG_DIR, 'plugins-config');
       const configFile = resolvePluginConfigFile(configDir, name);
@@ -2798,6 +3343,13 @@ class PluginsService {
       lspServers: data.lspServers || null,
       commands: data.commands || [],
       hooks: data.hooks || [],
+      resourceTypes: normalizeOmpResourceTypes(data.resourceTypes || data.resources),
+      resources: data.resources || null,
+      containsSkills: Boolean(data.containsSkills),
+      skillPaths: Array.isArray(data.skillPaths) ? data.skillPaths : [],
+      pluginKind: data.pluginKind || (data.containsSkills ? 'skill-bundle' : 'plugin'),
+      pluginType: data.pluginType || '',
+      strict: data.strict,
       isInstalled: false
     };
   }
@@ -2982,6 +3534,7 @@ class PluginsService {
     const results = [];
     for (const plugin of marketplace.plugins) {
       const sourceInfo = this._repoFromMarketplaceSource(repo, plugin.source);
+      const skillPaths = normalizeMarketplaceSkillPaths(plugin.skills);
       const canReadManifest = sourceInfo.repo.provider === 'local' || sourceInfo.repo.id === repo.id;
       const manifest = canReadManifest
         ? await this._readManifestFromRepo(sourceInfo.repo, sourceInfo.directory, [
@@ -3003,7 +3556,11 @@ class PluginsService {
         marketplaceFormat: 'claude-marketplace',
         lspServers: plugin.lspServers || null,
         commands: manifest?.commands || [],
-        hooks: manifest?.hooks || []
+        hooks: manifest?.hooks || [],
+        containsSkills: skillPaths.length > 0,
+        skillPaths,
+        pluginKind: skillPaths.length > 0 ? 'skill-bundle' : 'plugin',
+        strict: Object.prototype.hasOwnProperty.call(plugin, 'strict') ? plugin.strict : undefined
       }));
     }
     return results;
@@ -3041,6 +3598,96 @@ class PluginsService {
     return results;
   }
 
+  _normalizeOmpCatalogEntries(catalog = null) {
+    if (Array.isArray(catalog)) return catalog;
+    if (!catalog || typeof catalog !== 'object') return [];
+    for (const key of ['packages', 'plugins', 'extensions']) {
+      if (Array.isArray(catalog[key])) return catalog[key];
+    }
+    return [];
+  }
+
+  _normalizeOmpCatalogPackage(repo, entry = {}, catalog = {}, defaults = {}) {
+    if (!entry || typeof entry !== 'object') return null;
+    const installSource = String(
+      entry.installSource ||
+      entry.source ||
+      entry.package ||
+      entry.url ||
+      entry.repo ||
+      entry.repository ||
+      entry.name ||
+      ''
+    ).trim();
+    const name = String(entry.name || entry.id || entry.package || installSource || '').trim();
+    if (!name || !installSource) return null;
+
+    const resourceTypes = normalizeOmpResourceTypes(
+      entry.resourceTypes ||
+      entry.resources ||
+      entry.provides ||
+      entry.omp?.resources ||
+      defaults.resourceTypes
+    );
+    return this.buildMarketPluginItem(repo, {
+      name,
+      displayName: entry.displayName || entry.title || '',
+      description: entry.description || '',
+      author: entry.author || catalog.author || repo.owner,
+      version: entry.version || 'latest',
+      category: entry.category || 'general',
+      directory: entry.directory || name,
+      marketplace: entry.marketplace || repo.marketplace || catalog.name || defaults.marketplace || '',
+      installSource,
+      marketplaceFormat: defaults.marketplaceFormat || 'omp-package-catalog',
+      pluginKind: 'package',
+      pluginType: 'package',
+      resourceTypes,
+      resources: entry.resources || entry.provides || null,
+      repoUrl: entry.repoUrl || entry.repositoryUrl || entry.repository || repo.repoUrl || buildRepoUrl(repo)
+    });
+  }
+
+  async _fetchOmpPackageCatalogPlugins(repo, fileMap, readJson) {
+    if (!this._isOmp()) return [];
+    const catalogFiles = ['omp-packages.json', '.omp/packages.json', 'packages.json'];
+    for (const catalogPath of catalogFiles) {
+      if (!fileMap.has(catalogPath)) continue;
+      const catalog = await readJson(catalogPath);
+      const entries = this._normalizeOmpCatalogEntries(catalog);
+      const plugins = entries
+        .map(entry => this._normalizeOmpCatalogPackage(repo, entry, catalog, {
+          marketplaceFormat: 'omp-package-catalog'
+        }))
+        .filter(Boolean);
+      if (plugins.length > 0) return plugins;
+    }
+
+    const manifestPath = fileMap.has('omp.json') ? 'omp.json' : (fileMap.has('package.json') ? 'package.json' : '');
+    if (!manifestPath) return [];
+    const manifest = await readJson(manifestPath);
+    const ompMeta = manifest.omp && typeof manifest.omp === 'object' ? manifest.omp: {};
+    const installSource = ompMeta.installSource || manifest.installSource || manifest.name;
+    const resourceTypes = normalizeOmpResourceTypes(
+      ompMeta.resourceTypes ||
+      ompMeta.resources ||
+      manifest.resourceTypes ||
+      manifest.resources
+    );
+    if (!installSource || resourceTypes.length === 0) return [];
+    const plugin = this._normalizeOmpCatalogPackage(repo, {
+      name: manifest.name || repo.name,
+      installSource,
+      version: manifest.version,
+      description: manifest.description,
+      author: manifest.author,
+      resourceTypes
+    }, { name: repo.marketplace || repo.name }, {
+      marketplaceFormat: manifestPath === 'omp.json' ? 'omp-manifest' : 'omp-package-manifest'
+    });
+    return plugin ? [plugin] : [];
+  }
+
   /**
    * Get market plugins from configured repositories
    * @returns {Promise<Array>} List of available market plugins
@@ -3117,6 +3764,15 @@ class PluginsService {
           }
         }
 
+        // OMP package catalog format; legacy catalog filenames may still include omp.
+        if (this._isOmp()) {
+          const ompPackagePlugins = await this._fetchOmpPackageCatalogPlugins(repo, fileMap, readJson);
+          if (ompPackagePlugins.length > 0) {
+            marketPlugins.push(...ompPackagePlugins);
+            continue;
+          }
+        }
+
         const nestedManifestFiles = files.filter(file => {
           if (this._isCodex()) {
             return file.path === '.codex-plugin/plugin.json' || file.path.endsWith('/.codex-plugin/plugin.json');
@@ -3162,7 +3818,12 @@ class PluginsService {
 
         for (const dir of pluginDirs) {
           try {
-            const manifest = await readJson(`${dir}/plugin.json`);
+            const manifest = this._isOmp()
+              ? await this._readManifestFromRepo(repo, dir, ['omp.json', 'extension.json', 'plugin.json', 'package.json'])
+              : await readJson(`${dir}/plugin.json`);
+            if (!manifest) {
+              throw new Error(`File not found: ${dir}/plugin.json`);
+            }
 
             marketPlugins.push(this.buildMarketPluginItem(repo, {
               name: manifest.name || dir,
@@ -3170,6 +3831,7 @@ class PluginsService {
               author: manifest.author || repo.owner,
               version: manifest.version || '1.0.0',
               directory: dir,
+              pluginKind: this._isOmp() ? 'extension' : undefined,
               commands: manifest.commands || [],
               hooks: manifest.hooks || []
             }));