@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/server/extensions/ExtensionManager.js

@@ -1,431 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { basename, dirname, join } from 'node:path';
-import { allTools } from '../ToolCatalog.js';
-import { logger } from '../../utils/logger.js';
-import { INSTALLED_EXTENSION_METADATA_FILENAME } from '../extensions/types.js';
-import { DEFAULT_PLUGIN_ROOTS, DEFAULT_WORKFLOW_ROOTS, parseRoots, resolveRoots, } from './ExtensionManager.roots.js';
-import { sha256Hex, normalizeHex, isPluginStrictLoad, parseDigestAllowlist, verifyPluginIntegrity, } from './ExtensionManager.integrity.js';
-import { isExtensionBuilder, isWorkflowContract } from './ExtensionManager.guards.js';
-import { discoverPluginFiles, discoverWorkflowFiles } from './ExtensionManager.discovery.js';
-import { extractConfigValue, createFreshImportUrl, clearLoadedExtensionTools, buildListResult, } from './ExtensionManager.lifecycle.js';
-export function listExtensions(ctx) {
-    const pluginRoots = resolveRoots(parseRoots(process.env.MCP_PLUGIN_ROOTS, DEFAULT_PLUGIN_ROOTS));
-    const workflowRoots = resolveRoots(parseRoots(process.env.MCP_WORKFLOW_ROOTS, DEFAULT_WORKFLOW_ROOTS));
-    return buildListResult(ctx, pluginRoots, workflowRoots);
-}
-function parseSimpleYaml(filePath) {
-    try {
-        const text = readFileSync(filePath, 'utf-8');
-        const result = {};
-        for (const line of text.split(/\r?\n/)) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith('#'))
-                continue;
-            const colonIdx = trimmed.indexOf(':');
-            if (colonIdx < 1)
-                continue;
-            const key = trimmed.slice(0, colonIdx).trim();
-            const value = trimmed.slice(colonIdx + 1).trim();
-            if (key)
-                result[key] = value;
-        }
-        return result;
-    }
-    catch {
-        return {};
-    }
-}
-function findInstalledMetadataRoot(startDir) {
-    let currentDir = startDir;
-    while (true) {
-        if (existsSync(join(currentDir, INSTALLED_EXTENSION_METADATA_FILENAME))) {
-            return currentDir;
-        }
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir) {
-            return null;
-        }
-        currentDir = parentDir;
-    }
-}
-function resolvePluginProjectRoot(pluginFile) {
-    const entryDir = dirname(pluginFile);
-    const metadataRoot = findInstalledMetadataRoot(entryDir);
-    if (metadataRoot) {
-        return metadataRoot;
-    }
-    if (basename(entryDir).toLowerCase() === 'dist') {
-        return dirname(entryDir);
-    }
-    return entryDir;
-}
-let reloadMutex = Promise.resolve();
-const lazyWorkflowLoadAttempted = new WeakSet();
-const STRICT_PLUGIN_ALLOWLIST_ERROR = 'MCP_PLUGIN_ALLOWED_DIGESTS is required when MCP_PLUGIN_SIGNATURE_REQUIRED=true ' +
-    'or MCP_PLUGIN_STRICT_LOAD=true. The digest allowlist is the only pre-import trust boundary — ' +
-    'without it, plugin code executes before integrity verification. No plugins will be loaded.';
-const MISSING_PLUGIN_ALLOWLIST_WARNING = '[extensions] Loading plugins WITHOUT MCP_PLUGIN_ALLOWED_DIGESTS allowlist. ' +
-    'Plugin code will execute on import() before post-load integrity checks. ' +
-    'Set MCP_PLUGIN_STRICT_LOAD=true to enforce allowlist requirement.';
-async function withReloadMutex(operation) {
-    const prev = reloadMutex;
-    let resolve;
-    reloadMutex = new Promise((r) => {
-        resolve = r;
-    });
-    await prev;
-    try {
-        return await operation();
-    }
-    finally {
-        resolve();
-    }
-}
-export async function reloadExtensions(ctx) {
-    return withReloadMutex(() => reloadExtensionsInner(ctx));
-}
-export async function ensureWorkflowsLoaded(ctx) {
-    if (ctx.extensionWorkflowRuntimeById.size > 0 || lazyWorkflowLoadAttempted.has(ctx)) {
-        return;
-    }
-    await withReloadMutex(async () => {
-        if (ctx.extensionWorkflowRuntimeById.size > 0 || lazyWorkflowLoadAttempted.has(ctx)) {
-            return;
-        }
-        lazyWorkflowLoadAttempted.add(ctx);
-        const warnings = [];
-        const errors = [];
-        const pluginRoots = resolveRoots(parseRoots(process.env.MCP_PLUGIN_ROOTS, DEFAULT_PLUGIN_ROOTS));
-        const workflowRoots = resolveRoots(parseRoots(process.env.MCP_WORKFLOW_ROOTS, DEFAULT_WORKFLOW_ROOTS));
-        await loadPluginWorkflowContributions(ctx, pluginRoots, warnings, errors);
-        const workflowFiles = await discoverWorkflowFiles(workflowRoots);
-        await loadWorkflows(ctx, workflowFiles, warnings, errors);
-        for (const warning of warnings) {
-            logger.warn(`[extensions] ${warning}`);
-        }
-        for (const error of errors) {
-            logger.error(`[extensions] ${error}`);
-        }
-    });
-}
-async function loadWorkflows(ctx, workflowFiles, warnings, errors) {
-    for (const workflowFile of workflowFiles) {
-        try {
-            const mod = await import(createFreshImportUrl(workflowFile, 'workflow'));
-            const candidate = mod.default ?? mod;
-            if (!isWorkflowContract(candidate)) {
-                warnings.push(`Skip workflow file without valid WorkflowContract: ${workflowFile}`);
-                continue;
-            }
-            const workflow = candidate;
-            registerWorkflowContract(ctx, workflow, workflowFile, warnings);
-        }
-        catch (error) {
-            errors.push(`Failed to import workflow file ${workflowFile}: ${String(error)}`);
-        }
-    }
-}
-function registerWorkflowContract(ctx, workflow, source, warnings) {
-    if (ctx.extensionWorkflowsById.has(workflow.id)) {
-        warnings.push(`Skip workflow "${workflow.id}" from ${source}: duplicate id`);
-        return false;
-    }
-    const record = {
-        id: workflow.id,
-        displayName: workflow.displayName,
-        source,
-        description: workflow.description,
-        tags: workflow.tags,
-        timeoutMs: workflow.timeoutMs,
-        defaultMaxConcurrency: workflow.defaultMaxConcurrency,
-        route: workflow.route,
-    };
-    ctx.extensionWorkflowsById.set(record.id, record);
-    const runtimeRecord = {
-        workflow,
-        source,
-        route: workflow.route,
-    };
-    ctx.extensionWorkflowRuntimeById.set(record.id, runtimeRecord);
-    return true;
-}
-function buildPluginRecord(plugin, pluginFile, loadedTools, loadedWorkflows) {
-    return {
-        id: plugin.id,
-        name: plugin.pluginName,
-        source: pluginFile,
-        author: plugin.pluginAuthor || undefined,
-        sourceRepo: plugin.pluginSourceRepo || undefined,
-        domains: [],
-        workflows: loadedWorkflows,
-        tools: loadedTools,
-    };
-}
-async function loadPluginWorkflowContributions(ctx, pluginRoots, warnings, errors) {
-    const allowedDigests = parseDigestAllowlist(process.env.MCP_PLUGIN_ALLOWED_DIGESTS);
-    const strictLoad = isPluginStrictLoad();
-    if (strictLoad && allowedDigests.size === 0) {
-        errors.push(STRICT_PLUGIN_ALLOWLIST_ERROR);
-        logger.error('[extensions] ' + STRICT_PLUGIN_ALLOWLIST_ERROR);
-        return;
-    }
-    if (allowedDigests.size === 0) {
-        logger.warn(MISSING_PLUGIN_ALLOWLIST_WARNING);
-    }
-    const pluginFiles = await discoverPluginFiles(pluginRoots);
-    const coreVersion = ctx.config?.mcp?.version ?? '0.0.0';
-    for (const pluginFile of pluginFiles) {
-        let fileDigest;
-        try {
-            fileDigest = normalizeHex(await sha256Hex(pluginFile));
-            if (allowedDigests.size > 0 && !allowedDigests.has(fileDigest)) {
-                warnings.push(`Skip plugin file not in MCP_PLUGIN_ALLOWED_DIGESTS allowlist: ${pluginFile}`);
-                continue;
-            }
-        }
-        catch (error) {
-            errors.push(`Failed to hash plugin file ${pluginFile}: ${String(error)}`);
-            continue;
-        }
-        let plugin;
-        try {
-            const mod = await import(createFreshImportUrl(pluginFile, 'plugin'));
-            const candidate = mod.default ?? mod;
-            if (!isExtensionBuilder(candidate)) {
-                warnings.push(`Skip plugin file without valid ExtensionBuilder: ${pluginFile}`);
-                continue;
-            }
-            plugin = candidate;
-        }
-        catch (error) {
-            errors.push(`Failed to import plugin file ${pluginFile}: ${String(error)}`);
-            continue;
-        }
-        const pluginProjectRoot = resolvePluginProjectRoot(pluginFile);
-        const metaYamlPath = join(pluginProjectRoot, 'meta.yaml');
-        const meta = parseSimpleYaml(metaYamlPath);
-        plugin.mergeMetadata(meta);
-        if (ctx.extensionPluginsById.has(plugin.id)) {
-            warnings.push(`Skip plugin "${plugin.id}" from ${pluginFile}: duplicate plugin id`);
-            continue;
-        }
-        try {
-            const verification = await verifyPluginIntegrity(plugin, coreVersion);
-            warnings.push(...verification.warnings);
-            if (!verification.ok) {
-                errors.push(...verification.errors);
-                continue;
-            }
-        }
-        catch (error) {
-            errors.push(`Failed to verify plugin ${plugin.id}: ${String(error)}`);
-            continue;
-        }
-        const loadedWorkflows = [];
-        for (const candidate of plugin.workflows) {
-            if (!isWorkflowContract(candidate)) {
-                warnings.push(`Skip invalid workflow contribution from plugin "${plugin.id}" in ${pluginFile}`);
-                continue;
-            }
-            const workflowSource = `${pluginFile}#workflow:${candidate.id}`;
-            if (registerWorkflowContract(ctx, candidate, workflowSource, warnings)) {
-                loadedWorkflows.push(candidate.id);
-            }
-        }
-        if (loadedWorkflows.length === 0) {
-            continue;
-        }
-        ctx.extensionPluginsById.set(plugin.id, buildPluginRecord(plugin, pluginFile, [], loadedWorkflows));
-    }
-}
-async function reloadExtensionsInner(ctx) {
-    const warnings = [];
-    const errors = [];
-    const removedTools = await clearLoadedExtensionTools(ctx);
-    const pluginRoots = resolveRoots(parseRoots(process.env.MCP_PLUGIN_ROOTS, DEFAULT_PLUGIN_ROOTS));
-    const workflowRoots = resolveRoots(parseRoots(process.env.MCP_WORKFLOW_ROOTS, DEFAULT_WORKFLOW_ROOTS));
-    const allowedDigests = parseDigestAllowlist(process.env.MCP_PLUGIN_ALLOWED_DIGESTS);
-    const strictLoad = isPluginStrictLoad();
-    if (strictLoad && allowedDigests.size === 0) {
-        const msg = STRICT_PLUGIN_ALLOWLIST_ERROR;
-        errors.push(msg);
-        logger.error('[extensions] ' + msg);
-        const workflowFiles = await discoverWorkflowFiles(workflowRoots);
-        await loadWorkflows(ctx, workflowFiles, warnings, errors);
-        ctx.lastExtensionReloadAt = new Date().toISOString();
-        const list = buildListResult(ctx, pluginRoots, workflowRoots);
-        return { ...list, addedTools: 0, removedTools, warnings, errors };
-    }
-    if (allowedDigests.size === 0) {
-        logger.warn(MISSING_PLUGIN_ALLOWLIST_WARNING);
-    }
-    const baseToolNames = new Set(allTools.map((tool) => tool.name));
-    const pluginFiles = await discoverPluginFiles(pluginRoots);
-    const coreVersion = ctx.config?.mcp?.version ?? '0.0.0';
-    for (const pluginFile of pluginFiles) {
-        let fileDigest;
-        try {
-            fileDigest = normalizeHex(await sha256Hex(pluginFile));
-            if (allowedDigests.size > 0 && !allowedDigests.has(fileDigest)) {
-                warnings.push(`Skip plugin file not in MCP_PLUGIN_ALLOWED_DIGESTS allowlist: ${pluginFile}`);
-                continue;
-            }
-        }
-        catch (error) {
-            errors.push(`Failed to hash plugin file ${pluginFile}: ${String(error)}`);
-            continue;
-        }
-        let plugin;
-        try {
-            const mod = await import(createFreshImportUrl(pluginFile, 'plugin'));
-            const candidate = mod.default ?? mod;
-            if (!isExtensionBuilder(candidate)) {
-                warnings.push(`Skip plugin file without valid ExtensionBuilder: ${pluginFile}`);
-                continue;
-            }
-            plugin = candidate;
-        }
-        catch (error) {
-            errors.push(`Failed to import plugin file ${pluginFile}: ${String(error)}`);
-            continue;
-        }
-        const pluginProjectRoot = resolvePluginProjectRoot(pluginFile);
-        const metaYamlPath = join(pluginProjectRoot, 'meta.yaml');
-        const meta = parseSimpleYaml(metaYamlPath);
-        plugin.mergeMetadata(meta);
-        if (ctx.extensionPluginsById.has(plugin.id)) {
-            warnings.push(`Skip plugin "${plugin.id}" from ${pluginFile}: duplicate plugin id`);
-            continue;
-        }
-        try {
-            const verification = await verifyPluginIntegrity(plugin, coreVersion);
-            warnings.push(...verification.warnings);
-            if (!verification.ok) {
-                errors.push(...verification.errors);
-                continue;
-            }
-        }
-        catch (error) {
-            errors.push(`Failed to verify plugin ${plugin.id}: ${String(error)}`);
-            continue;
-        }
-        const runtimeData = new Map();
-        const metrics = new Set();
-        let pluginState = 'loaded';
-        const allowInvokeAll = plugin.allowedTools.includes('*');
-        const lifecycleContext = {
-            pluginId: plugin.id,
-            pluginRoot: pluginProjectRoot,
-            config: ctx.config,
-            get state() {
-                return pluginState;
-            },
-            registerMetric(metricName) {
-                metrics.add(metricName);
-            },
-            async invokeTool(name, args = {}) {
-                if (typeof name !== 'string' || name.length === 0) {
-                    throw new Error('invokeTool requires a non-empty tool name');
-                }
-                if (!allowInvokeAll && !plugin.allowedTools.includes(name)) {
-                    throw new Error(`Plugin "${plugin.id}" is not allowed to invoke "${name}". ` +
-                        'Declare it in allowTool calls.');
-                }
-                if (!baseToolNames.has(name)) {
-                    throw new Error(`Plugin "${plugin.id}" can only invoke built-in tools. "${name}" is not built-in.`);
-                }
-                if (!ctx.router.has(name)) {
-                    throw new Error(`Tool "${name}" is not available in the current active profile.`);
-                }
-                return ctx.executeToolWithTracking(name, (args ?? {}));
-            },
-            hasPermission(_capability) {
-                return true;
-            },
-            getConfig(path, fallback) {
-                return extractConfigValue(ctx, path, fallback);
-            },
-            setRuntimeData(key, value) {
-                runtimeData.set(key, value);
-            },
-            getRuntimeData(key) {
-                return runtimeData.get(key);
-            },
-        };
-        const runtimeRecord = {
-            plugin,
-            lifecycleContext,
-            state: pluginState,
-            source: pluginFile,
-        };
-        try {
-            if (plugin.onLoadHandler) {
-                await plugin.onLoadHandler(lifecycleContext);
-            }
-            pluginState = 'loaded';
-            runtimeRecord.state = pluginState;
-            if (plugin.onValidateHandler) {
-                const validation = await plugin.onValidateHandler(lifecycleContext);
-                if (!validation.valid) {
-                    warnings.push(`Plugin ${plugin.id} validation failed: ${validation.errors.join('; ')}`);
-                    continue;
-                }
-                pluginState = 'validated';
-                runtimeRecord.state = pluginState;
-            }
-            if (plugin.onActivateHandler) {
-                await plugin.onActivateHandler(lifecycleContext);
-                pluginState = 'activated';
-                runtimeRecord.state = pluginState;
-            }
-            ctx.extensionPluginRuntimeById.set(plugin.id, runtimeRecord);
-        }
-        catch (error) {
-            try {
-                if (plugin.onDeactivateHandler && pluginState === 'activated') {
-                    await plugin.onDeactivateHandler(lifecycleContext);
-                    pluginState = 'deactivated';
-                    runtimeRecord.state = pluginState;
-                }
-            }
-            catch (deactivateError) {
-                logger.warn(`Plugin onDeactivate failed during rollback for ${plugin.id}:`, deactivateError);
-            }
-            errors.push(`Plugin lifecycle failed for ${plugin.id}: ${String(error)}`);
-            continue;
-        }
-        const loadedTools = plugin.tools.map((t) => t.name);
-        const loadedWorkflows = [];
-        for (const candidate of plugin.workflows) {
-            if (!isWorkflowContract(candidate)) {
-                warnings.push(`Skip invalid workflow contribution from plugin "${plugin.id}" in ${pluginFile}`);
-                continue;
-            }
-            const workflowSource = `${pluginFile}#workflow:${candidate.id}`;
-            if (registerWorkflowContract(ctx, candidate, workflowSource, warnings)) {
-                loadedWorkflows.push(candidate.id);
-            }
-        }
-        const record = buildPluginRecord(plugin, pluginFile, loadedTools, loadedWorkflows);
-        ctx.extensionPluginsById.set(record.id, record);
-    }
-    const workflowFiles = await discoverWorkflowFiles(workflowRoots);
-    await loadWorkflows(ctx, workflowFiles, warnings, errors);
-    if (ctx.extensionToolsByName.size > 0 || removedTools > 0) {
-        try {
-            await ctx.server.sendToolListChanged();
-        }
-        catch (error) {
-            logger.warn('sendToolListChanged failed after extension reload:', error);
-        }
-    }
-    ctx.lastExtensionReloadAt = new Date().toISOString();
-    const list = buildListResult(ctx, pluginRoots, workflowRoots);
-    return {
-        ...list,
-        addedTools: ctx.extensionToolsByName.size,
-        removedTools,
-        warnings,
-        errors,
-    };
-}

package/dist/src/server/extensions/ExtensionManager.lifecycle.d.ts

@@ -1,6 +0,0 @@
-import type { MCPServerContext } from '../MCPServer.context.js';
-import type { ExtensionListResult } from '../extensions/types.js';
-export declare function extractConfigValue<T = unknown>(ctx: MCPServerContext, path: string, fallback?: T): T;
-export declare function createFreshImportUrl(modulePath: string, kind: 'plugin' | 'workflow'): string;
-export declare function clearLoadedExtensionTools(ctx: MCPServerContext): Promise<number>;
-export declare function buildListResult(ctx: MCPServerContext, pluginRoots: string[], workflowRoots: string[]): ExtensionListResult;

package/dist/src/server/extensions/ExtensionManager.lifecycle.js

@@ -1,75 +0,0 @@
-import { pathToFileURL } from 'node:url';
-import { logger } from '../../utils/logger.js';
-export function extractConfigValue(ctx, path, fallback) {
-    const segments = path.split('.').filter(Boolean);
-    let current = ctx.config;
-    for (const segment of segments) {
-        if (!current || typeof current !== 'object')
-            return fallback;
-        current = current[segment];
-    }
-    return current ?? fallback;
-}
-export function createFreshImportUrl(modulePath, kind) {
-    const moduleUrl = new URL(pathToFileURL(modulePath).href);
-    moduleUrl.searchParams.set('reloadTs', String(Date.now()));
-    logger.debug(`[extensions] Loading fresh ${kind} module: ${modulePath}`);
-    return moduleUrl.href;
-}
-export async function clearLoadedExtensionTools(ctx) {
-    let removed = 0;
-    for (const [pluginId, runtime] of ctx.extensionPluginRuntimeById.entries()) {
-        try {
-            if (runtime.plugin.onDeactivateHandler && runtime.state === 'activated') {
-                await runtime.plugin.onDeactivateHandler(runtime.lifecycleContext);
-                runtime.state = 'deactivated';
-            }
-        }
-        catch (error) {
-            logger.warn(`Plugin onDeactivate failed for "${pluginId}":`, error);
-        }
-        try {
-            if (runtime.plugin.onDeactivateHandler) {
-                runtime.state = 'unloaded';
-            }
-        }
-        catch (error) {
-            logger.warn(`Plugin onUnload failed for "${pluginId}":`, error);
-        }
-    }
-    for (const record of ctx.extensionToolsByName.values()) {
-        try {
-            record.registeredTool?.remove();
-        }
-        catch (error) {
-            logger.warn(`Failed to remove extension tool "${record.name}":`, error);
-        }
-        ctx.router.removeHandler(record.name);
-        ctx.activatedToolNames.delete(record.name);
-        ctx.activatedRegisteredTools.delete(record.name);
-        removed++;
-    }
-    ctx.extensionToolsByName.clear();
-    ctx.extensionPluginsById.clear();
-    ctx.extensionPluginRuntimeById.clear();
-    ctx.extensionWorkflowsById.clear();
-    ctx.extensionWorkflowRuntimeById.clear();
-    return removed;
-}
-export function buildListResult(ctx, pluginRoots, workflowRoots) {
-    return {
-        pluginRoots,
-        workflowRoots,
-        pluginCount: ctx.extensionPluginsById.size,
-        workflowCount: ctx.extensionWorkflowsById.size,
-        toolCount: ctx.extensionToolsByName.size,
-        lastReloadAt: ctx.lastExtensionReloadAt,
-        plugins: [...ctx.extensionPluginsById.values()],
-        workflows: [...ctx.extensionWorkflowsById.values()],
-        tools: [...ctx.extensionToolsByName.values()].map((record) => ({
-            name: record.name,
-            domain: record.domain,
-            source: record.source,
-        })),
-    };
-}

package/dist/src/server/extensions/ExtensionManager.roots.d.ts

@@ -1,4 +0,0 @@
-export declare const DEFAULT_PLUGIN_ROOTS: string[];
-export declare const DEFAULT_WORKFLOW_ROOTS: string[];
-export declare function parseRoots(raw: string | undefined, fallback: string[]): string[];
-export declare function resolveRoots(roots: string[], baseDir?: string): string[];

package/dist/src/server/extensions/ExtensionManager.roots.js

@@ -1,33 +0,0 @@
-import { dirname, isAbsolute, join, resolve } from 'node:path';
-import { existsSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-function findProjectRoot(startDir) {
-    let dir = startDir;
-    while (true) {
-        if (existsSync(join(dir, 'package.json')))
-            return dir;
-        const parent = dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return resolve(startDir, '..', '..', '..', '..');
-}
-const EXTENSION_MANAGER_DIR = fileURLToPath(new URL('.', import.meta.url));
-const EXTENSION_INSTALL_ROOT = findProjectRoot(EXTENSION_MANAGER_DIR);
-export const DEFAULT_PLUGIN_ROOTS = [join(EXTENSION_INSTALL_ROOT, 'plugins')];
-export const DEFAULT_WORKFLOW_ROOTS = [join(EXTENSION_INSTALL_ROOT, 'workflows')];
-export function parseRoots(raw, fallback) {
-    const value = raw?.trim();
-    if (!value)
-        return fallback;
-    const roots = value
-        .split(',')
-        .map((item) => item.trim())
-        .filter(Boolean);
-    return roots.length > 0 ? [...new Set(roots)] : fallback;
-}
-export function resolveRoots(roots, baseDir = EXTENSION_INSTALL_ROOT) {
-    const resolved = roots.map((root) => (isAbsolute(root) ? root : resolve(baseDir, root)));
-    return [...new Set(resolved)].toSorted((a, b) => a.localeCompare(b));
-}

package/dist/src/server/extensions/ExtensionManager.version.d.ts

@@ -1,3 +0,0 @@
-export declare function parseVersionParts(version: string): [number, number, number] | null;
-export declare function compareVersion(a: string, b: string): number | null;
-export declare function isCompatibleVersion(range: string, currentVersion: string): boolean;

package/dist/src/server/extensions/ExtensionManager.version.js

@@ -1,57 +0,0 @@
-export function parseVersionParts(version) {
-    const match = version.trim().match(/^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/);
-    if (!match)
-        return null;
-    return [Number(match[1]), Number(match[2]), Number(match[3])];
-}
-export function compareVersion(a, b) {
-    const aa = parseVersionParts(a);
-    const bb = parseVersionParts(b);
-    if (!aa || !bb)
-        return null;
-    const [aMajor, aMinor, aPatch] = aa;
-    const [bMajor, bMinor, bPatch] = bb;
-    if (aMajor > bMajor)
-        return 1;
-    if (aMajor < bMajor)
-        return -1;
-    if (aMinor > bMinor)
-        return 1;
-    if (aMinor < bMinor)
-        return -1;
-    if (aPatch > bPatch)
-        return 1;
-    if (aPatch < bPatch)
-        return -1;
-    return 0;
-}
-export function isCompatibleVersion(range, currentVersion) {
-    const input = range.trim();
-    if (!input || input === '*')
-        return true;
-    if (input.startsWith('>=')) {
-        const base = input.slice(2).trim();
-        const cmp = compareVersion(currentVersion, base);
-        return cmp !== null && cmp >= 0;
-    }
-    if (input.startsWith('^')) {
-        const base = input.slice(1).trim();
-        const cc = parseVersionParts(currentVersion);
-        const bb = parseVersionParts(base);
-        if (!cc || !bb)
-            return false;
-        const cmp = compareVersion(currentVersion, base);
-        return cmp !== null && cmp >= 0 && cc[0] === bb[0];
-    }
-    if (input.startsWith('~')) {
-        const base = input.slice(1).trim();
-        const cc = parseVersionParts(currentVersion);
-        const bb = parseVersionParts(base);
-        if (!cc || !bb)
-            return false;
-        const cmp = compareVersion(currentVersion, base);
-        return cmp !== null && cmp >= 0 && cc[0] === bb[0] && cc[1] === bb[1];
-    }
-    const cmp = compareVersion(currentVersion, input);
-    return cmp !== null && cmp === 0;
-}

package/dist/src/server/extensions/plugin-config.d.ts

@@ -1,4 +0,0 @@
-import type { PluginLifecycleContext } from '../plugins/PluginContract.js';
-export declare function getPluginBooleanConfig(ctx: PluginLifecycleContext, pluginId: string, key: string, fallback: boolean): boolean;
-export type BoostTier = 'search' | 'workflow' | 'full';
-export declare function getPluginBoostTier(pluginId: string): BoostTier;

package/dist/src/server/extensions/plugin-config.js

@@ -1,46 +0,0 @@
-function normalizeSegment(value) {
-    return value
-        .trim()
-        .replace(/[^a-zA-Z0-9]+/g, '_')
-        .replace(/^_+|_+$/g, '')
-        .toUpperCase();
-}
-function envCandidates(pluginId, key) {
-    const pluginSegment = normalizeSegment(pluginId);
-    const keySegment = normalizeSegment(key);
-    return [`PLUGIN_${pluginSegment}_${keySegment}`, `PLUGINS_${pluginSegment}_${keySegment}`];
-}
-function parseBoolean(raw) {
-    if (raw === undefined)
-        return undefined;
-    const value = raw.trim().toLowerCase();
-    if (['1', 'true', 'yes', 'on'].includes(value))
-        return true;
-    if (['0', 'false', 'no', 'off'].includes(value))
-        return false;
-    return undefined;
-}
-export function getPluginBooleanConfig(ctx, pluginId, key, fallback) {
-    for (const candidate of envCandidates(pluginId, key)) {
-        const parsed = parseBoolean(process.env[candidate]);
-        if (parsed !== undefined)
-            return parsed;
-    }
-    return ctx.getConfig(`plugins.${pluginId}.${key}`, fallback);
-}
-const VALID_BOOST_TIERS = new Set([
-    'search',
-    'workflow',
-    'full',
-]);
-export function getPluginBoostTier(pluginId) {
-    for (const candidate of envCandidates(pluginId, 'BOOST_DOMAIN')) {
-        const raw = process.env[candidate]?.trim().toLowerCase();
-        if (raw && VALID_BOOST_TIERS.has(raw))
-            return raw;
-    }
-    const globalDefault = process.env.MCP_DEFAULT_PLUGIN_BOOST_TIER?.trim().toLowerCase();
-    if (globalDefault && VALID_BOOST_TIERS.has(globalDefault))
-        return globalDefault;
-    return 'full';
-}

package/dist/src/server/extensions/plugin-env.d.ts

@@ -1 +0,0 @@
-export declare function loadPluginEnv(manifestLocation: string): void;