@sstar/skill-install 1.0.0 → 1.1.0

package/dist/plugins/plugin-manager.js

@@ -0,0 +1,475 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginManager = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const os_1 = require("os");
+const logger_1 = require("../core/logger");
+const errors_1 = require("../core/errors");
+const plugin_validator_1 = require("./plugin-validator");
+/**
+ * Manages Claude Code plugins and marketplaces
+ */
+class PluginManager {
+    constructor() {
+        this.logger = new logger_1.Logger('PluginManager');
+        this.validator = new plugin_validator_1.PluginValidator();
+        this.pluginsDir = (0, path_1.join)((0, os_1.homedir)(), '.claude', 'plugins');
+        this.marketplacesDir = (0, path_1.join)(this.pluginsDir, 'marketplaces');
+        this.cacheDir = (0, path_1.join)(this.pluginsDir, 'cache');
+        this.knownMarketplacesFile = (0, path_1.join)(this.pluginsDir, 'known_marketplaces.json');
+        this.installedPluginsFile = (0, path_1.join)(this.pluginsDir, 'installed_plugins.json');
+        this.settingsFile = (0, path_1.join)((0, os_1.homedir)(), '.claude', 'settings.json');
+    }
+    /**
+     * Initialize directories and files
+     */
+    async initialize() {
+        await (0, promises_1.mkdir)(this.pluginsDir, { recursive: true });
+        await (0, promises_1.mkdir)(this.marketplacesDir, { recursive: true });
+        await (0, promises_1.mkdir)(this.cacheDir, { recursive: true });
+        // Initialize known_marketplaces.json if not exists
+        try {
+            await (0, promises_1.readFile)(this.knownMarketplacesFile, 'utf-8');
+        }
+        catch {
+            await (0, promises_1.writeFile)(this.knownMarketplacesFile, JSON.stringify({}, null, 2));
+        }
+        // Initialize installed_plugins.json if not exists
+        try {
+            await (0, promises_1.readFile)(this.installedPluginsFile, 'utf-8');
+        }
+        catch {
+            const empty = { version: 2, plugins: {} };
+            await (0, promises_1.writeFile)(this.installedPluginsFile, JSON.stringify(empty, null, 2));
+        }
+    }
+    /**
+     * Install a package (auto-detects Marketplace or Plugin)
+     */
+    async installPackage(extractDir, structure) {
+        await this.initialize();
+        switch (structure.type) {
+            case 'marketplace':
+                return await this.installMarketplace(extractDir, structure);
+            case 'plugin':
+                return await this.installStandalonePlugin(extractDir, structure.plugins[0]);
+            default:
+                throw new errors_1.WikiError(errors_1.ErrorType.INVALID_PACKAGE, `Unsupported package type: ${structure.type}`);
+        }
+    }
+    /**
+     * Install a Marketplace
+     * 1. Copy to marketplaces/{name}/
+     * 2. Update known_marketplaces.json
+     * 3. Optionally install plugins from it
+     */
+    async installMarketplace(extractDir, structure) {
+        const marketplace = structure.marketplace;
+        const targetDir = (0, path_1.join)(this.marketplacesDir, marketplace.name);
+        this.logger.info(`Installing marketplace "${marketplace.name}" to ${targetDir}`);
+        // Check if already exists
+        if (await this.pathExists(targetDir)) {
+            this.logger.warn(`Marketplace "${marketplace.name}" already exists, will overwrite`);
+        }
+        // 1. Copy marketplace directory
+        await this.copyDirectory(extractDir, targetDir);
+        // 2. Update known_marketplaces.json
+        // Use 'directory' source type for locally-installed marketplaces
+        await this.addKnownMarketplace({
+            source: { source: 'directory', path: targetDir },
+            installLocation: targetDir,
+            lastUpdated: new Date().toISOString(),
+        }, marketplace.name);
+        this.logger.info(`Marketplace "${marketplace.name}" installed successfully`);
+        // Return result - plugins installation is handled separately
+        return {
+            type: 'marketplace',
+            success: true,
+            marketplace: marketplace.name,
+            path: targetDir,
+        };
+    }
+    /**
+     * Install a plugin from an already-installed marketplace
+     */
+    async installPluginFromMarketplace(marketplaceName, pluginName, version) {
+        await this.initialize();
+        const marketplaceDir = (0, path_1.join)(this.marketplacesDir, marketplaceName);
+        const marketplaceJsonPath = (0, path_1.join)(marketplaceDir, '.claude-plugin', 'marketplace.json');
+        // Check if marketplace exists
+        if (!await this.pathExists(marketplaceJsonPath)) {
+            throw new errors_1.WikiError(errors_1.ErrorType.NOT_FOUND, `Marketplace "${marketplaceName}" not found. Please install it first.`);
+        }
+        // Read marketplace.json to get plugin info
+        const marketplace = await this.validator.validateMarketplaceOrThrow(marketplaceDir);
+        const pluginDef = marketplace.plugins.find(p => p.name === pluginName);
+        if (!pluginDef) {
+            throw new errors_1.WikiError(errors_1.ErrorType.NOT_FOUND, `Plugin "${pluginName}" not found in marketplace "${marketplaceName}"`);
+        }
+        // Resolve plugin source path
+        const pluginSourcePath = this.resolvePluginSourcePath(marketplaceDir, pluginDef.source, marketplace.metadata?.pluginRoot);
+        if (!pluginSourcePath || !await this.pathExists(pluginSourcePath)) {
+            throw new errors_1.WikiError(errors_1.ErrorType.NOT_FOUND, `Plugin source not found at: ${pluginSourcePath}`);
+        }
+        // Determine version
+        const versionToInstall = version || pluginDef.version || 'unknown';
+        // Target path in cache
+        const targetPath = (0, path_1.join)(this.cacheDir, marketplaceName, pluginName, versionToInstall);
+        this.logger.info(`Installing plugin "${pluginName}@${marketplaceName}" to ${targetPath}`);
+        // Copy plugin to cache
+        await (0, promises_1.mkdir)(targetPath, { recursive: true });
+        await this.copyDirectory(pluginSourcePath, targetPath);
+        // Update installed_plugins.json
+        await this.addInstalledPlugin({
+            name: `${pluginName}@${marketplaceName}`,
+            scope: 'user',
+            installPath: targetPath,
+            version: versionToInstall,
+            installedAt: new Date().toISOString(),
+            isLocal: true,
+        });
+        // Enable the plugin automatically
+        await this.enablePlugin(`${pluginName}@${marketplaceName}`);
+        this.logger.info(`Plugin "${pluginName}@${marketplaceName}" installed successfully`);
+        return {
+            type: 'plugin',
+            success: true,
+            plugin: `${pluginName}@${marketplaceName}`,
+            version: versionToInstall,
+            marketplace: marketplaceName,
+            path: targetPath,
+        };
+    }
+    /**
+     * Install multiple plugins from a marketplace
+     */
+    async installPluginsFromMarketplace(marketplaceName, plugins, progressCallback) {
+        const results = [];
+        for (let i = 0; i < plugins.length; i++) {
+            const plugin = plugins[i];
+            if (progressCallback) {
+                progressCallback(i + 1, plugins.length, plugin.name);
+            }
+            try {
+                const result = await this.installPluginFromMarketplace(marketplaceName, plugin.name, plugin.version);
+                results.push(result);
+            }
+            catch (error) {
+                this.logger.error(`Failed to install plugin "${plugin.name}": ${error}`);
+                results.push({
+                    type: 'plugin',
+                    success: false,
+                    plugin: plugin.name,
+                    path: '',
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Install a standalone plugin (not from a marketplace)
+     */
+    async installStandalonePlugin(extractDir, plugin) {
+        // Install to cache/_standalone/
+        const version = plugin.version || '1.0.0';
+        const targetPath = (0, path_1.join)(this.cacheDir, '_standalone', plugin.name, version);
+        this.logger.info(`Installing standalone plugin "${plugin.name}" to ${targetPath}`);
+        await (0, promises_1.mkdir)(targetPath, { recursive: true });
+        await this.copyDirectory(extractDir, targetPath);
+        // Update installed_plugins.json
+        await this.addInstalledPlugin({
+            name: plugin.name,
+            scope: 'user',
+            installPath: targetPath,
+            version,
+            installedAt: new Date().toISOString(),
+            isLocal: true,
+        });
+        // Enable the plugin automatically
+        await this.enablePlugin(plugin.name);
+        this.logger.info(`Standalone plugin "${plugin.name}" installed successfully`);
+        return {
+            type: 'plugin',
+            success: true,
+            plugin: plugin.name,
+            version,
+            path: targetPath,
+        };
+    }
+    /**
+     * List installed plugins
+     */
+    async listInstalledPlugins() {
+        try {
+            const content = await (0, promises_1.readFile)(this.installedPluginsFile, 'utf-8');
+            const data = JSON.parse(content);
+            const plugins = [];
+            for (const [key, entries] of Object.entries(data.plugins)) {
+                plugins.push(...entries);
+            }
+            return plugins;
+        }
+        catch (error) {
+            this.logger.error(`Failed to read installed plugins: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * List known marketplaces
+     */
+    async listKnownMarketplaces() {
+        try {
+            const content = await (0, promises_1.readFile)(this.knownMarketplacesFile, 'utf-8');
+            const data = JSON.parse(content);
+            return Object.values(data);
+        }
+        catch (error) {
+            this.logger.error(`Failed to read known marketplaces: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Check if a marketplace is known
+     */
+    async isMarketplaceKnown(marketplaceName) {
+        const known = await this.listKnownMarketplaces();
+        return known.some(m => m.installLocation.includes(marketplaceName));
+    }
+    /**
+     * Check if a plugin is installed
+     */
+    async isPluginInstalled(pluginKey) {
+        try {
+            const content = await (0, promises_1.readFile)(this.installedPluginsFile, 'utf-8');
+            const data = JSON.parse(content);
+            return pluginKey in data.plugins && data.plugins[pluginKey].length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Uninstall a plugin
+     */
+    async uninstallPlugin(pluginKey) {
+        const { rm } = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+        const content = await (0, promises_1.readFile)(this.installedPluginsFile, 'utf-8');
+        const data = JSON.parse(content);
+        if (!(pluginKey in data.plugins)) {
+            throw new errors_1.WikiError(errors_1.ErrorType.NOT_FOUND, `Plugin "${pluginKey}" not found`);
+        }
+        // Remove all entries
+        for (const entry of data.plugins[pluginKey]) {
+            try {
+                await rm(entry.installPath, { recursive: true, force: true });
+                this.logger.info(`Removed plugin at: ${entry.installPath}`);
+            }
+            catch (error) {
+                this.logger.warn(`Failed to remove ${entry.installPath}: ${error}`);
+            }
+        }
+        delete data.plugins[pluginKey];
+        await (0, promises_1.writeFile)(this.installedPluginsFile, JSON.stringify(data, null, 2));
+        this.logger.info(`Plugin "${pluginKey}" uninstalled`);
+    }
+    /**
+     * Remove a marketplace
+     */
+    async removeMarketplace(marketplaceName) {
+        const { rm } = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+        const content = await (0, promises_1.readFile)(this.knownMarketplacesFile, 'utf-8');
+        const data = JSON.parse(content);
+        if (!(marketplaceName in data)) {
+            throw new errors_1.WikiError(errors_1.ErrorType.NOT_FOUND, `Marketplace "${marketplaceName}" not found`);
+        }
+        const marketplaceInfo = data[marketplaceName];
+        // Remove marketplace directory
+        try {
+            await rm(marketplaceInfo.installLocation, { recursive: true, force: true });
+            this.logger.info(`Removed marketplace at: ${marketplaceInfo.installLocation}`);
+        }
+        catch (error) {
+            this.logger.warn(`Failed to remove marketplace directory: ${error}`);
+        }
+        // Also remove cached plugins from this marketplace
+        const cachePath = (0, path_1.join)(this.cacheDir, marketplaceName);
+        try {
+            await rm(cachePath, { recursive: true, force: true });
+            this.logger.info(`Removed cached plugins from: ${cachePath}`);
+        }
+        catch (error) {
+            this.logger.warn(`Failed to remove cache directory: ${error}`);
+        }
+        delete data[marketplaceName];
+        await (0, promises_1.writeFile)(this.knownMarketplacesFile, JSON.stringify(data, null, 2));
+        this.logger.info(`Marketplace "${marketplaceName}" removed`);
+    }
+    /**
+     * Resolve plugin source path from marketplace
+     */
+    resolvePluginSourcePath(marketplaceDir, source, pluginRoot) {
+        let relativePath;
+        if (typeof source === 'string') {
+            relativePath = source;
+        }
+        else if (source.source === 'github' || source.source === 'url') {
+            // External source - can't resolve locally
+            return null;
+        }
+        else {
+            relativePath = source.source || '';
+        }
+        // Apply pluginRoot if present
+        if (pluginRoot && relativePath.startsWith('./')) {
+            relativePath = (0, path_1.join)(pluginRoot, relativePath.slice(2));
+        }
+        return (0, path_1.join)(marketplaceDir, relativePath);
+    }
+    /**
+     * Add a marketplace to known_marketplaces.json
+     */
+    async addKnownMarketplace(info, name) {
+        const content = await (0, promises_1.readFile)(this.knownMarketplacesFile, 'utf-8');
+        const data = JSON.parse(content);
+        data[name] = info;
+        await (0, promises_1.writeFile)(this.knownMarketplacesFile, JSON.stringify(data, null, 2));
+    }
+    /**
+     * Add a plugin to installed_plugins.json
+     */
+    async addInstalledPlugin(plugin) {
+        const content = await (0, promises_1.readFile)(this.installedPluginsFile, 'utf-8');
+        const data = JSON.parse(content);
+        const key = plugin.name;
+        if (!data.plugins[key]) {
+            data.plugins[key] = [];
+        }
+        // Remove existing entries with same scope
+        data.plugins[key] = data.plugins[key].filter((p) => p.scope !== plugin.scope);
+        data.plugins[key].push(plugin);
+        await (0, promises_1.writeFile)(this.installedPluginsFile, JSON.stringify(data, null, 2));
+    }
+    /**
+     * Enable a plugin in settings.json
+     * This adds the plugin to the enabledPlugins object
+     */
+    async enablePlugin(pluginKey) {
+        try {
+            let settings = {};
+            // Read existing settings
+            try {
+                const content = await (0, promises_1.readFile)(this.settingsFile, 'utf-8');
+                settings = JSON.parse(content);
+            }
+            catch {
+                // File doesn't exist or is empty, create new settings
+                settings = {};
+            }
+            // Initialize enabledPlugins if not exists
+            if (!settings.enabledPlugins) {
+                settings.enabledPlugins = {};
+            }
+            // Enable the plugin
+            settings.enabledPlugins[pluginKey] = true;
+            // Write settings
+            await (0, promises_1.writeFile)(this.settingsFile, JSON.stringify(settings, null, 2));
+            this.logger.info(`Plugin "${pluginKey}" enabled in settings.json`);
+        }
+        catch (error) {
+            this.logger.warn(`Failed to enable plugin in settings.json: ${error}`);
+            // Don't throw - this is not a critical failure
+        }
+    }
+    /**
+     * Disable a plugin in settings.json
+     */
+    async disablePlugin(pluginKey) {
+        try {
+            let settings = {};
+            // Read existing settings
+            try {
+                const content = await (0, promises_1.readFile)(this.settingsFile, 'utf-8');
+                settings = JSON.parse(content);
+            }
+            catch {
+                // File doesn't exist, nothing to disable
+                return;
+            }
+            // Remove from enabledPlugins
+            if (settings.enabledPlugins && pluginKey in settings.enabledPlugins) {
+                delete settings.enabledPlugins[pluginKey];
+                // Write settings
+                await (0, promises_1.writeFile)(this.settingsFile, JSON.stringify(settings, null, 2));
+                this.logger.info(`Plugin "${pluginKey}" disabled in settings.json`);
+            }
+        }
+        catch (error) {
+            this.logger.warn(`Failed to disable plugin in settings.json: ${error}`);
+        }
+    }
+    /**
+     * Copy a directory recursively
+     */
+    async copyDirectory(source, target) {
+        await (0, promises_1.mkdir)(target, { recursive: true });
+        const entries = await (0, promises_1.readdir)(source, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = (0, path_1.join)(source, entry.name);
+            const tgtPath = (0, path_1.join)(target, entry.name);
+            if (entry.isDirectory()) {
+                await this.copyDirectory(srcPath, tgtPath);
+            }
+            else {
+                await (0, promises_1.cp)(srcPath, tgtPath);
+            }
+        }
+    }
+    /**
+     * Check if a path exists
+     */
+    async pathExists(path) {
+        try {
+            await (0, promises_1.stat)(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.PluginManager = PluginManager;

package/dist/plugins/plugin-validator.d.ts

@@ -0,0 +1,35 @@
+import { PluginMetadata, MarketplaceMetadata, PluginDefinition } from './types';
+/**
+ * Validation result
+ */
+export interface ValidationResult<T> {
+    valid: boolean;
+    metadata?: T;
+    error?: string;
+}
+/**
+ * Validates plugin.json and marketplace.json files
+ */
+export declare class PluginValidator {
+    private readonly logger;
+    /**
+     * Validate a plugin.json file
+     */
+    validate(pluginDir: string): Promise<ValidationResult<PluginMetadata>>;
+    /**
+     * Validate plugin.json and throw WikiError if invalid
+     */
+    validateOrThrow(pluginDir: string): Promise<PluginMetadata>;
+    /**
+     * Validate a marketplace.json file
+     */
+    validateMarketplace(marketplaceDir: string): Promise<ValidationResult<MarketplaceMetadata>>;
+    /**
+     * Validate marketplace.json and throw WikiError if invalid
+     */
+    validateMarketplaceOrThrow(marketplaceDir: string): Promise<MarketplaceMetadata>;
+    /**
+     * Validate a plugin definition from marketplace.json
+     */
+    validatePluginDefinition(pluginDef: PluginDefinition): ValidationResult<PluginDefinition>;
+}

package/dist/plugins/plugin-validator.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginValidator = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const logger_1 = require("../core/logger");
+const errors_1 = require("../core/errors");
+/**
+ * Validates plugin.json and marketplace.json files
+ */
+class PluginValidator {
+    constructor() {
+        this.logger = new logger_1.Logger('PluginValidator');
+    }
+    /**
+     * Validate a plugin.json file
+     */
+    async validate(pluginDir) {
+        const pluginJsonPath = (0, path_1.join)(pluginDir, 'plugin.json');
+        try {
+            const content = await (0, promises_1.readFile)(pluginJsonPath, 'utf-8');
+            const data = JSON.parse(content);
+            // Validate required fields
+            if (!data.name || typeof data.name !== 'string') {
+                return {
+                    valid: false,
+                    error: 'Missing or invalid "name" field in plugin.json'
+                };
+            }
+            this.logger.info(`Valid plugin found: ${data.name}`);
+            return {
+                valid: true,
+                metadata: {
+                    name: data.name,
+                    version: data.version,
+                    description: data.description,
+                    author: data.author,
+                    homepage: data.homepage,
+                    repository: data.repository,
+                    license: data.license,
+                    keywords: data.keywords,
+                    commands: data.commands,
+                    agents: data.agents,
+                    hooks: data.hooks,
+                    mcpServers: data.mcpServers,
+                    lspServers: data.lspServers,
+                    claudeCode: data.claudeCode,
+                }
+            };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Validation error: ${errorMsg}`);
+            return {
+                valid: false,
+                error: errorMsg
+            };
+        }
+    }
+    /**
+     * Validate plugin.json and throw WikiError if invalid
+     */
+    async validateOrThrow(pluginDir) {
+        const result = await this.validate(pluginDir);
+        if (!result.valid) {
+            throw new errors_1.WikiError(errors_1.ErrorType.INVALID_SKILL, result.error || 'Invalid plugin', result.error ? new Error(result.error) : undefined);
+        }
+        return result.metadata;
+    }
+    /**
+     * Validate a marketplace.json file
+     */
+    async validateMarketplace(marketplaceDir) {
+        const marketplaceJsonPath = (0, path_1.join)(marketplaceDir, '.claude-plugin', 'marketplace.json');
+        try {
+            const content = await (0, promises_1.readFile)(marketplaceJsonPath, 'utf-8');
+            const data = JSON.parse(content);
+            // Validate required fields
+            if (!data.name || typeof data.name !== 'string') {
+                return {
+                    valid: false,
+                    error: 'Missing or invalid "name" field in marketplace.json'
+                };
+            }
+            if (!data.owner || !data.owner.name) {
+                return {
+                    valid: false,
+                    error: 'Missing or invalid "owner" field in marketplace.json'
+                };
+            }
+            if (!Array.isArray(data.plugins)) {
+                return {
+                    valid: false,
+                    error: 'Missing or invalid "plugins" array in marketplace.json'
+                };
+            }
+            this.logger.info(`Valid marketplace found: ${data.name} with ${data.plugins.length} plugin(s)`);
+            return {
+                valid: true,
+                metadata: {
+                    name: data.name,
+                    description: data.description,
+                    version: data.version,
+                    owner: data.owner,
+                    plugins: data.plugins,
+                    metadata: data.metadata,
+                }
+            };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Marketplace validation error: ${errorMsg}`);
+            return {
+                valid: false,
+                error: errorMsg
+            };
+        }
+    }
+    /**
+     * Validate marketplace.json and throw WikiError if invalid
+     */
+    async validateMarketplaceOrThrow(marketplaceDir) {
+        const result = await this.validateMarketplace(marketplaceDir);
+        if (!result.valid) {
+            throw new errors_1.WikiError(errors_1.ErrorType.INVALID_SKILL, result.error || 'Invalid marketplace', result.error ? new Error(result.error) : undefined);
+        }
+        return result.metadata;
+    }
+    /**
+     * Validate a plugin definition from marketplace.json
+     */
+    validatePluginDefinition(pluginDef) {
+        if (!pluginDef.name || typeof pluginDef.name !== 'string') {
+            return {
+                valid: false,
+                error: 'Missing or invalid "name" field in plugin definition'
+            };
+        }
+        if (!pluginDef.source) {
+            return {
+                valid: false,
+                error: 'Missing "source" field in plugin definition'
+            };
+        }
+        return {
+            valid: true,
+            metadata: pluginDef
+        };
+    }
+}
+exports.PluginValidator = PluginValidator;