thaddeus 1.0.26 → 1.0.28

package/src/utils/plugins/loadPluginHooks.js

@@ -0,0 +1,239 @@
+import memoize from 'lodash-es/memoize.js';
+import { clearRegisteredPluginHooks, getRegisteredHooks, registerHookCallbacks, } from '../../bootstrap/state.js';
+import { logForDebugging } from '../debug.js';
+import { settingsChangeDetector } from '../settings/changeDetector.js';
+import { getSettings_DEPRECATED, getSettingsForSource, } from '../settings/settings.js';
+import { jsonStringify } from '../slowOperations.js';
+import { clearPluginCache, loadAllPluginsCacheOnly } from './pluginLoader.js';
+// Track if hot reload subscription is set up
+let hotReloadSubscribed = false;
+// Snapshot of enabledPlugins for change detection in hot reload
+let lastPluginSettingsSnapshot;
+/**
+ * Convert plugin hooks configuration to native matchers with plugin context
+ */
+function convertPluginHooksToMatchers(plugin) {
+    const pluginMatchers = {
+        PreToolUse: [],
+        PostToolUse: [],
+        PostToolUseFailure: [],
+        PermissionDenied: [],
+        Notification: [],
+        UserPromptSubmit: [],
+        SessionStart: [],
+        SessionEnd: [],
+        Stop: [],
+        StopFailure: [],
+        SubagentStart: [],
+        SubagentStop: [],
+        PreCompact: [],
+        PostCompact: [],
+        PermissionRequest: [],
+        Setup: [],
+        TeammateIdle: [],
+        TaskCreated: [],
+        TaskCompleted: [],
+        Elicitation: [],
+        ElicitationResult: [],
+        ConfigChange: [],
+        WorktreeCreate: [],
+        WorktreeRemove: [],
+        InstructionsLoaded: [],
+        CwdChanged: [],
+        FileChanged: [],
+    };
+    if (!plugin.hooksConfig) {
+        return pluginMatchers;
+    }
+    // Process each hook event - pass through all hook types with plugin context
+    for (const [event, matchers] of Object.entries(plugin.hooksConfig)) {
+        const hookEvent = event;
+        if (!pluginMatchers[hookEvent]) {
+            continue;
+        }
+        for (const matcher of matchers) {
+            if (matcher.hooks.length > 0) {
+                pluginMatchers[hookEvent].push({
+                    matcher: matcher.matcher,
+                    hooks: matcher.hooks,
+                    pluginRoot: plugin.path,
+                    pluginName: plugin.name,
+                    pluginId: plugin.source,
+                });
+            }
+        }
+    }
+    return pluginMatchers;
+}
+/**
+ * Load and register hooks from all enabled plugins
+ */
+export const loadPluginHooks = memoize(async () => {
+    const { enabled } = await loadAllPluginsCacheOnly();
+    const allPluginHooks = {
+        PreToolUse: [],
+        PostToolUse: [],
+        PostToolUseFailure: [],
+        PermissionDenied: [],
+        Notification: [],
+        UserPromptSubmit: [],
+        SessionStart: [],
+        SessionEnd: [],
+        Stop: [],
+        StopFailure: [],
+        SubagentStart: [],
+        SubagentStop: [],
+        PreCompact: [],
+        PostCompact: [],
+        PermissionRequest: [],
+        Setup: [],
+        TeammateIdle: [],
+        TaskCreated: [],
+        TaskCompleted: [],
+        Elicitation: [],
+        ElicitationResult: [],
+        ConfigChange: [],
+        WorktreeCreate: [],
+        WorktreeRemove: [],
+        InstructionsLoaded: [],
+        CwdChanged: [],
+        FileChanged: [],
+    };
+    // Process each enabled plugin
+    for (const plugin of enabled) {
+        if (!plugin.hooksConfig) {
+            continue;
+        }
+        logForDebugging(`Loading hooks from plugin: ${plugin.name}`);
+        const pluginMatchers = convertPluginHooksToMatchers(plugin);
+        // Merge plugin hooks into the main collection
+        for (const event of Object.keys(pluginMatchers)) {
+            allPluginHooks[event].push(...pluginMatchers[event]);
+        }
+    }
+    // Clear-then-register as an atomic pair. Previously the clear lived in
+    // clearPluginHookCache(), which meant any clearAllCaches() call (from
+    // /plugins UI, pluginInstallationHelpers, thinkback, etc.) wiped plugin
+    // hooks from STATE.registeredHooks and left them wiped until someone
+    // happened to call loadPluginHooks() again. SessionStart explicitly awaits
+    // loadPluginHooks() before firing so it always re-registered; Stop has no
+    // such guard, so plugin Stop hooks silently never fired after any plugin
+    // management operation (gh-29767). Doing the clear here makes the swap
+    // atomic — old hooks stay valid until this point, new hooks take over.
+    clearRegisteredPluginHooks();
+    registerHookCallbacks(allPluginHooks);
+    const totalHooks = Object.values(allPluginHooks).reduce((sum, matchers) => sum + matchers.reduce((s, m) => s + m.hooks.length, 0), 0);
+    logForDebugging(`Registered ${totalHooks} hooks from ${enabled.length} plugins`);
+});
+export function clearPluginHookCache() {
+    // Only invalidate the memoize — do NOT wipe STATE.registeredHooks here.
+    // Wiping here left plugin hooks dead between clearAllCaches() and the next
+    // loadPluginHooks() call, which for Stop hooks might never happen
+    // (gh-29767). The clear now lives inside loadPluginHooks() as an atomic
+    // clear-then-register, so old hooks stay valid until the fresh load swaps
+    // them out.
+    loadPluginHooks.cache?.clear?.();
+}
+/**
+ * Remove hooks from plugins no longer in the enabled set, without adding
+ * hooks from newly-enabled plugins. Called from clearAllCaches() so
+ * uninstalled/disabled plugins stop firing hooks immediately (gh-36995),
+ * while newly-enabled plugins wait for /reload-plugins — consistent with
+ * how commands/agents/MCP behave.
+ *
+ * The full swap (clear + register all) still happens via loadPluginHooks(),
+ * which /reload-plugins awaits.
+ */
+export async function pruneRemovedPluginHooks() {
+    // Early return when nothing to prune — avoids seeding the loadAllPluginsCacheOnly
+    // memoize in test/preload.ts beforeEach (which clears registeredHooks).
+    if (!getRegisteredHooks())
+        return;
+    const { enabled } = await loadAllPluginsCacheOnly();
+    const enabledRoots = new Set(enabled.map(p => p.path));
+    // Re-read after the await: a concurrent loadPluginHooks() (hot-reload)
+    // could have swapped STATE.registeredHooks during the gap. Holding the
+    // pre-await reference would compute survivors from stale data.
+    const current = getRegisteredHooks();
+    if (!current)
+        return;
+    // Collect plugin hooks whose pluginRoot is still enabled, then swap via
+    // the existing clear+register pair (same atomic-pair pattern as
+    // loadPluginHooks above). Callback hooks are preserved by
+    // clearRegisteredPluginHooks; we only need to re-register survivors.
+    const survivors = {};
+    for (const [event, matchers] of Object.entries(current)) {
+        const kept = matchers.filter((m) => 'pluginRoot' in m && enabledRoots.has(m.pluginRoot));
+        if (kept.length > 0)
+            survivors[event] = kept;
+    }
+    clearRegisteredPluginHooks();
+    registerHookCallbacks(survivors);
+}
+/**
+ * Reset hot reload subscription state. Only for testing.
+ */
+export function resetHotReloadState() {
+    hotReloadSubscribed = false;
+    lastPluginSettingsSnapshot = undefined;
+}
+/**
+ * Build a stable string snapshot of the settings that feed into
+ * `loadAllPluginsCacheOnly()` for change detection. Sorts keys so comparison is
+ * deterministic regardless of insertion order.
+ *
+ * Hashes FOUR fields — not just enabledPlugins — because the memoized
+ * loadAllPluginsCacheOnly() also reads strictKnownMarketplaces, blockedMarketplaces
+ * (pluginLoader.ts:1933 via getBlockedMarketplaces), and
+ * extraKnownMarketplaces. If remote managed settings set only one of
+ * these (no enabledPlugins), a snapshot keyed only on enabledPlugins
+ * would never diff, the listener would skip, and the memoized result
+ * would retain the pre-remote marketplace allow/blocklist.
+ * See #23085 / #23152 poisoned-cache discussion (Slack C09N89L3VNJ).
+ */
+// Exported for testing — the listener at setupPluginHookHotReload uses this
+// for change detection; tests verify it diffs on the fields that matter.
+export function getPluginAffectingSettingsSnapshot() {
+    const merged = getSettings_DEPRECATED();
+    const policy = getSettingsForSource('policySettings');
+    // Key-sort the two Record fields so insertion order doesn't flap the hash.
+    // Array fields (strictKnownMarketplaces, blockedMarketplaces) have
+    // schema-stable order.
+    const sortKeys = (o) => o ? Object.fromEntries(Object.entries(o).sort()) : {};
+    return jsonStringify({
+        enabledPlugins: sortKeys(merged.enabledPlugins),
+        extraKnownMarketplaces: sortKeys(merged.extraKnownMarketplaces),
+        strictKnownMarketplaces: policy?.strictKnownMarketplaces ?? [],
+        blockedMarketplaces: policy?.blockedMarketplaces ?? [],
+    });
+}
+/**
+ * Set up hot reload for plugin hooks when remote settings change.
+ * When policySettings changes (e.g., from remote managed settings),
+ * compares the plugin-affecting settings snapshot and only reloads if it
+ * actually changed.
+ */
+export function setupPluginHookHotReload() {
+    if (hotReloadSubscribed) {
+        return;
+    }
+    hotReloadSubscribed = true;
+    // Capture the initial snapshot so the first policySettings change can compare
+    lastPluginSettingsSnapshot = getPluginAffectingSettingsSnapshot();
+    settingsChangeDetector.subscribe(source => {
+        if (source === 'policySettings') {
+            const newSnapshot = getPluginAffectingSettingsSnapshot();
+            if (newSnapshot === lastPluginSettingsSnapshot) {
+                logForDebugging('Plugin hooks: skipping reload, plugin-affecting settings unchanged');
+                return;
+            }
+            lastPluginSettingsSnapshot = newSnapshot;
+            logForDebugging('Plugin hooks: reloading due to plugin-affecting settings change');
+            // Clear all plugin-related caches
+            clearPluginCache('loadPluginHooks: plugin-affecting settings changed');
+            clearPluginHookCache();
+            // Reload hooks (fire-and-forget, don't block)
+            void loadPluginHooks();
+        }
+    });
+}

package/src/utils/plugins/loadPluginOutputStyles.js

@@ -0,0 +1,112 @@
+import memoize from 'lodash-es/memoize.js';
+import { basename } from 'path';
+import { getPluginErrorMessage } from '../../types/plugin.js';
+import { logForDebugging } from '../debug.js';
+import { coerceDescriptionToString, parseFrontmatter, } from '../frontmatterParser.js';
+import { getFsImplementation, isDuplicatePath } from '../fsOperations.js';
+import { extractDescriptionFromMarkdown } from '../markdownConfigLoader.js';
+import { loadAllPluginsCacheOnly } from './pluginLoader.js';
+import { walkPluginMarkdown } from './walkPluginMarkdown.js';
+async function loadOutputStylesFromDirectory(outputStylesPath, pluginName, loadedPaths) {
+    const styles = [];
+    await walkPluginMarkdown(outputStylesPath, async (fullPath) => {
+        const style = await loadOutputStyleFromFile(fullPath, pluginName, loadedPaths);
+        if (style)
+            styles.push(style);
+    }, { logLabel: 'output-styles' });
+    return styles;
+}
+async function loadOutputStyleFromFile(filePath, pluginName, loadedPaths) {
+    const fs = getFsImplementation();
+    if (isDuplicatePath(fs, filePath, loadedPaths)) {
+        return null;
+    }
+    try {
+        const content = await fs.readFile(filePath, { encoding: 'utf-8' });
+        const { frontmatter, content: markdownContent } = parseFrontmatter(content, filePath);
+        const fileName = basename(filePath, '.md');
+        const baseStyleName = frontmatter.name || fileName;
+        // Namespace output styles with plugin name, consistent with commands and agents
+        const name = `${pluginName}:${baseStyleName}`;
+        const description = coerceDescriptionToString(frontmatter.description, name) ??
+            extractDescriptionFromMarkdown(markdownContent, `Output style from ${pluginName} plugin`);
+        // Parse forceForPlugin flag (supports both boolean and string values)
+        const forceRaw = frontmatter['force-for-plugin'];
+        const forceForPlugin = forceRaw === true || forceRaw === 'true'
+            ? true
+            : forceRaw === false || forceRaw === 'false'
+                ? false
+                : undefined;
+        return {
+            name,
+            description,
+            prompt: markdownContent.trim(),
+            source: 'plugin',
+            forceForPlugin,
+        };
+    }
+    catch (error) {
+        logForDebugging(`Failed to load output style from ${filePath}: ${error}`, {
+            level: 'error',
+        });
+        return null;
+    }
+}
+export const loadPluginOutputStyles = memoize(async () => {
+    // Only load output styles from enabled plugins
+    const { enabled, errors } = await loadAllPluginsCacheOnly();
+    const allStyles = [];
+    if (errors.length > 0) {
+        logForDebugging(`Plugin loading errors: ${errors.map(e => getPluginErrorMessage(e)).join(', ')}`);
+    }
+    for (const plugin of enabled) {
+        // Track loaded file paths to prevent duplicates within this plugin
+        const loadedPaths = new Set();
+        // Load output styles from default output-styles directory
+        if (plugin.outputStylesPath) {
+            try {
+                const styles = await loadOutputStylesFromDirectory(plugin.outputStylesPath, plugin.name, loadedPaths);
+                allStyles.push(...styles);
+                if (styles.length > 0) {
+                    logForDebugging(`Loaded ${styles.length} output styles from plugin ${plugin.name} default directory`);
+                }
+            }
+            catch (error) {
+                logForDebugging(`Failed to load output styles from plugin ${plugin.name} default directory: ${error}`, { level: 'error' });
+            }
+        }
+        // Load output styles from additional paths specified in manifest
+        if (plugin.outputStylesPaths) {
+            for (const stylePath of plugin.outputStylesPaths) {
+                try {
+                    const fs = getFsImplementation();
+                    const stats = await fs.stat(stylePath);
+                    if (stats.isDirectory()) {
+                        // Load all .md files from directory
+                        const styles = await loadOutputStylesFromDirectory(stylePath, plugin.name, loadedPaths);
+                        allStyles.push(...styles);
+                        if (styles.length > 0) {
+                            logForDebugging(`Loaded ${styles.length} output styles from plugin ${plugin.name} custom path: ${stylePath}`);
+                        }
+                    }
+                    else if (stats.isFile() && stylePath.endsWith('.md')) {
+                        // Load single output style file
+                        const style = await loadOutputStyleFromFile(stylePath, plugin.name, loadedPaths);
+                        if (style) {
+                            allStyles.push(style);
+                            logForDebugging(`Loaded output style from plugin ${plugin.name} custom file: ${stylePath}`);
+                        }
+                    }
+                }
+                catch (error) {
+                    logForDebugging(`Failed to load output styles from plugin ${plugin.name} custom path ${stylePath}: ${error}`, { level: 'error' });
+                }
+            }
+        }
+    }
+    logForDebugging(`Total plugin output styles loaded: ${allStyles.length}`);
+    return allStyles;
+});
+export function clearPluginOutputStyleCache() {
+    loadPluginOutputStyles.cache?.clear?.();
+}

package/src/utils/plugins/lspPluginIntegration.js

@@ -0,0 +1,293 @@
+import { readFile } from 'fs/promises';
+import { join, relative, resolve } from 'path';
+import { z } from 'zod/v4';
+import { expandEnvVarsInString } from '../../services/mcp/envExpansion.js';
+import { logForDebugging } from '../debug.js';
+import { isENOENT, toError } from '../errors.js';
+import { logError } from '../log.js';
+import { jsonParse } from '../slowOperations.js';
+import { getPluginDataDir } from './pluginDirectories.js';
+import { getPluginStorageId, loadPluginOptions, substitutePluginVariables, substituteUserConfigVariables, } from './pluginOptionsStorage.js';
+import { LspServerConfigSchema } from './schemas.js';
+/**
+ * Validate that a resolved path stays within the plugin directory.
+ * Prevents path traversal attacks via .. or absolute paths.
+ */
+function validatePathWithinPlugin(pluginPath, relativePath) {
+    // Resolve both paths to absolute paths
+    const resolvedPluginPath = resolve(pluginPath);
+    const resolvedFilePath = resolve(pluginPath, relativePath);
+    // Check if the resolved file path is within the plugin directory
+    const rel = relative(resolvedPluginPath, resolvedFilePath);
+    // If relative path starts with .. or is absolute, it's outside the plugin dir
+    if (rel.startsWith('..') || resolve(rel) === rel) {
+        return null;
+    }
+    return resolvedFilePath;
+}
+/**
+ * Load LSP server configurations from a plugin.
+ * Checks for:
+ * 1. .lsp.json file in plugin directory
+ * 2. manifest.lspServers field
+ *
+ * @param plugin - The loaded plugin
+ * @param errors - Array to collect any errors encountered
+ * @returns Record of server name to config, or undefined if no servers
+ */
+export async function loadPluginLspServers(plugin, errors = []) {
+    const servers = {};
+    // 1. Check for .lsp.json file in plugin directory
+    const lspJsonPath = join(plugin.path, '.lsp.json');
+    try {
+        const content = await readFile(lspJsonPath, 'utf-8');
+        const parsed = jsonParse(content);
+        const result = z
+            .record(z.string(), LspServerConfigSchema())
+            .safeParse(parsed);
+        if (result.success) {
+            Object.assign(servers, result.data);
+        }
+        else {
+            const errorMsg = `LSP config validation failed for .lsp.json in plugin ${plugin.name}: ${result.error.message}`;
+            logError(new Error(errorMsg));
+            errors.push({
+                type: 'lsp-config-invalid',
+                plugin: plugin.name,
+                serverName: '.lsp.json',
+                validationError: result.error.message,
+                source: 'plugin',
+            });
+        }
+    }
+    catch (error) {
+        // .lsp.json is optional, ignore if it doesn't exist
+        if (!isENOENT(error)) {
+            const _errorMsg = error instanceof Error
+                ? `Failed to read/parse .lsp.json in plugin ${plugin.name}: ${error.message}`
+                : `Failed to read/parse .lsp.json file in plugin ${plugin.name}`;
+            logError(toError(error));
+            errors.push({
+                type: 'lsp-config-invalid',
+                plugin: plugin.name,
+                serverName: '.lsp.json',
+                validationError: error instanceof Error
+                    ? `Failed to parse JSON: ${error.message}`
+                    : 'Failed to parse JSON file',
+                source: 'plugin',
+            });
+        }
+    }
+    // 2. Check manifest.lspServers field
+    if (plugin.manifest.lspServers) {
+        const manifestServers = await loadLspServersFromManifest(plugin.manifest.lspServers, plugin.path, plugin.name, errors);
+        if (manifestServers) {
+            Object.assign(servers, manifestServers);
+        }
+    }
+    return Object.keys(servers).length > 0 ? servers : undefined;
+}
+/**
+ * Load LSP servers from manifest declaration (handles multiple formats).
+ */
+async function loadLspServersFromManifest(declaration, pluginPath, pluginName, errors) {
+    const servers = {};
+    // Normalize to array
+    const declarations = Array.isArray(declaration) ? declaration : [declaration];
+    for (const decl of declarations) {
+        if (typeof decl === 'string') {
+            // Validate path to prevent directory traversal
+            const validatedPath = validatePathWithinPlugin(pluginPath, decl);
+            if (!validatedPath) {
+                const securityMsg = `Security: Path traversal attempt blocked in plugin ${pluginName}: ${decl}`;
+                logError(new Error(securityMsg));
+                logForDebugging(securityMsg, { level: 'warn' });
+                errors.push({
+                    type: 'lsp-config-invalid',
+                    plugin: pluginName,
+                    serverName: decl,
+                    validationError: 'Invalid path: must be relative and within plugin directory',
+                    source: 'plugin',
+                });
+                continue;
+            }
+            // Load from file
+            try {
+                const content = await readFile(validatedPath, 'utf-8');
+                const parsed = jsonParse(content);
+                const result = z
+                    .record(z.string(), LspServerConfigSchema())
+                    .safeParse(parsed);
+                if (result.success) {
+                    Object.assign(servers, result.data);
+                }
+                else {
+                    const errorMsg = `LSP config validation failed for ${decl} in plugin ${pluginName}: ${result.error.message}`;
+                    logError(new Error(errorMsg));
+                    errors.push({
+                        type: 'lsp-config-invalid',
+                        plugin: pluginName,
+                        serverName: decl,
+                        validationError: result.error.message,
+                        source: 'plugin',
+                    });
+                }
+            }
+            catch (error) {
+                const _errorMsg = error instanceof Error
+                    ? `Failed to read/parse LSP config from ${decl} in plugin ${pluginName}: ${error.message}`
+                    : `Failed to read/parse LSP config file ${decl} in plugin ${pluginName}`;
+                logError(toError(error));
+                errors.push({
+                    type: 'lsp-config-invalid',
+                    plugin: pluginName,
+                    serverName: decl,
+                    validationError: error instanceof Error
+                        ? `Failed to parse JSON: ${error.message}`
+                        : 'Failed to parse JSON file',
+                    source: 'plugin',
+                });
+            }
+        }
+        else {
+            // Inline configs
+            for (const [serverName, config] of Object.entries(decl)) {
+                const result = LspServerConfigSchema().safeParse(config);
+                if (result.success) {
+                    servers[serverName] = result.data;
+                }
+                else {
+                    const errorMsg = `LSP config validation failed for inline server "${serverName}" in plugin ${pluginName}: ${result.error.message}`;
+                    logError(new Error(errorMsg));
+                    errors.push({
+                        type: 'lsp-config-invalid',
+                        plugin: pluginName,
+                        serverName,
+                        validationError: result.error.message,
+                        source: 'plugin',
+                    });
+                }
+            }
+        }
+    }
+    return Object.keys(servers).length > 0 ? servers : undefined;
+}
+/**
+ * Resolve environment variables for plugin LSP servers.
+ * Handles ${CLAUDE_PLUGIN_ROOT}, ${user_config.X}, and general ${VAR}
+ * substitution. Tracks missing environment variables for error reporting.
+ */
+export function resolvePluginLspEnvironment(config, plugin, userConfig, _errors) {
+    const allMissingVars = [];
+    const resolveValue = (value) => {
+        // First substitute plugin-specific variables
+        let resolved = substitutePluginVariables(value, plugin);
+        // Then substitute user config variables if provided
+        if (userConfig) {
+            resolved = substituteUserConfigVariables(resolved, userConfig);
+        }
+        // Finally expand general environment variables
+        const { expanded, missingVars } = expandEnvVarsInString(resolved);
+        allMissingVars.push(...missingVars);
+        return expanded;
+    };
+    const resolved = { ...config };
+    // Resolve command path
+    if (resolved.command) {
+        resolved.command = resolveValue(resolved.command);
+    }
+    // Resolve args
+    if (resolved.args) {
+        resolved.args = resolved.args.map(arg => resolveValue(arg));
+    }
+    // Resolve environment variables and add CLAUDE_PLUGIN_ROOT / CLAUDE_PLUGIN_DATA
+    const resolvedEnv = {
+        CLAUDE_PLUGIN_ROOT: plugin.path,
+        CLAUDE_PLUGIN_DATA: getPluginDataDir(plugin.source),
+        ...(resolved.env || {}),
+    };
+    for (const [key, value] of Object.entries(resolvedEnv)) {
+        if (key !== 'CLAUDE_PLUGIN_ROOT' && key !== 'CLAUDE_PLUGIN_DATA') {
+            resolvedEnv[key] = resolveValue(value);
+        }
+    }
+    resolved.env = resolvedEnv;
+    // Resolve workspaceFolder if present
+    if (resolved.workspaceFolder) {
+        resolved.workspaceFolder = resolveValue(resolved.workspaceFolder);
+    }
+    // Log missing variables if any were found
+    if (allMissingVars.length > 0) {
+        const uniqueMissingVars = [...new Set(allMissingVars)];
+        const warnMsg = `Missing environment variables in plugin LSP config: ${uniqueMissingVars.join(', ')}`;
+        logError(new Error(warnMsg));
+        logForDebugging(warnMsg, { level: 'warn' });
+    }
+    return resolved;
+}
+/**
+ * Add plugin scope to LSP server configs
+ * This adds a prefix to server names to avoid conflicts between plugins
+ */
+export function addPluginScopeToLspServers(servers, pluginName) {
+    const scopedServers = {};
+    for (const [name, config] of Object.entries(servers)) {
+        // Add plugin prefix to server name to avoid conflicts
+        const scopedName = `plugin:${pluginName}:${name}`;
+        scopedServers[scopedName] = {
+            ...config,
+            scope: 'dynamic', // Use dynamic scope for plugin servers
+            source: pluginName,
+        };
+    }
+    return scopedServers;
+}
+/**
+ * Get LSP servers from a specific plugin with environment variable resolution and scoping
+ * This function is called when the LSP servers need to be activated and ensures they have
+ * the proper environment variables and scope applied
+ */
+export async function getPluginLspServers(plugin, errors = []) {
+    if (!plugin.enabled) {
+        return undefined;
+    }
+    // Use cached servers if available
+    const servers = plugin.lspServers || (await loadPluginLspServers(plugin, errors));
+    if (!servers) {
+        return undefined;
+    }
+    // Resolve environment variables. Top-level manifest.userConfig values
+    // become available as ${user_config.KEY} in LSP command/args/env.
+    // Gate on manifest.userConfig — same rationale as buildMcpUserConfig:
+    // loadPluginOptions always returns {} so without this guard userConfig is
+    // truthy for every plugin and substituteUserConfigVariables throws on any
+    // unresolved ${user_config.X}. Also skips unneeded keychain reads.
+    const userConfig = plugin.manifest.userConfig
+        ? loadPluginOptions(getPluginStorageId(plugin))
+        : undefined;
+    const resolvedServers = {};
+    for (const [name, config] of Object.entries(servers)) {
+        resolvedServers[name] = resolvePluginLspEnvironment(config, plugin, userConfig, errors);
+    }
+    // Add plugin scope
+    return addPluginScopeToLspServers(resolvedServers, plugin.name);
+}
+/**
+ * Extract all LSP servers from loaded plugins
+ */
+export async function extractLspServersFromPlugins(plugins, errors = []) {
+    const allServers = {};
+    for (const plugin of plugins) {
+        if (!plugin.enabled)
+            continue;
+        const servers = await loadPluginLspServers(plugin, errors);
+        if (servers) {
+            const scopedServers = addPluginScopeToLspServers(servers, plugin.name);
+            Object.assign(allServers, scopedServers);
+            // Store the servers on the plugin for caching
+            plugin.lspServers = servers;
+            logForDebugging(`Loaded ${Object.keys(servers).length} LSP servers from plugin ${plugin.name}`);
+        }
+    }
+    return allServers;
+}