@xenosystem/agent-interface-host 0.1.3

package/dist/pluginMcp/PluginMcpManagerService.js

@@ -0,0 +1,1821 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'fs';
+import { createHash } from 'crypto';
+import { homedir } from 'os';
+import { dirname, join, resolve } from 'path';
+import { createScopeAcl, estimateTokens, normalizeSearchText, stableDocumentId } from '../agentSearch/searchUtils.js';
+const DEFAULT_REGISTRY_POLICY = 'context';
+const MAX_PLUGIN_EVENTS = 500;
+const MAX_PREVIEW_BYTES = 8_000;
+class PluginMcpDeniedError extends Error {
+    denial;
+    constructor(denial) {
+        super(denial.message);
+        this.name = 'PluginMcpDeniedError';
+        this.denial = denial;
+    }
+}
+let sdkModulePromise = null;
+function loadSdk() {
+    if (!sdkModulePromise)
+        sdkModulePromise = import('@xenosystem/agent-sdk');
+    return sdkModulePromise;
+}
+function safeReadJson(path, fallback) {
+    try {
+        if (!existsSync(path))
+            return fallback;
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return fallback;
+    }
+}
+function ensureDir(path) {
+    if (!existsSync(path))
+        mkdirSync(path, { recursive: true });
+}
+function safeWriteJson(path, value) {
+    ensureDir(dirname(path));
+    const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+    writeFileSync(tmp, JSON.stringify(value, null, 2) + '\n', 'utf-8');
+    renameSync(tmp, path);
+}
+function optionalString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    const seen = new Set();
+    const out = [];
+    for (const entry of value) {
+        if (typeof entry !== 'string')
+            continue;
+        const trimmed = entry.trim();
+        const key = trimmed.toLowerCase();
+        if (!trimmed || seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(trimmed);
+    }
+    return out;
+}
+function stringRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (typeof entry !== 'string')
+            continue;
+        if (!key.trim())
+            continue;
+        out[key.trim()] = entry;
+    }
+    return out;
+}
+function numberTimestamp(value, fallback = Date.now()) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function normalizeMcpScope(value) {
+    return value === 'project' || value === 'mcprc' || value === 'session' || value === 'user'
+        ? value
+        : 'user';
+}
+function normalizeRegistryPolicy(value) {
+    return value === 'none' || value === 'prompts' || value === 'resources' || value === 'context' || value === 'all'
+        ? value
+        : DEFAULT_REGISTRY_POLICY;
+}
+function normalizePolicyKey(value) {
+    return typeof value === 'string' ? value.trim().toLowerCase() : '';
+}
+function normalizedList(value) {
+    const seen = new Set();
+    const out = [];
+    for (const entry of stringArray(value)) {
+        const key = normalizePolicyKey(entry);
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(entry.trim());
+    }
+    return out;
+}
+function normalizeCaller(value) {
+    const record = value && typeof value === 'object' ? value : {};
+    return {
+        workspaceId: optionalString(record.workspaceId),
+        teamId: optionalString(record.teamId),
+        agentId: optionalString(record.agentId),
+        allowedDirectories: stringArray(record.allowedDirectories),
+    };
+}
+function normalizePolicyScope(value) {
+    const record = value && typeof value === 'object' ? value : {};
+    const type = record.type === 'workspace' || record.type === 'team' || record.type === 'agent' ? record.type : 'global';
+    return {
+        type,
+        workspaceId: optionalString(record.workspaceId),
+        teamId: optionalString(record.teamId),
+        agentId: optionalString(record.agentId),
+    };
+}
+function policyScopeId(scope) {
+    if (scope.type === 'agent')
+        return `agent:${scope.workspaceId || '*'}:${scope.teamId || '*'}:${scope.agentId || '*'}`;
+    if (scope.type === 'team')
+        return `team:${scope.workspaceId || '*'}:${scope.teamId || '*'}`;
+    if (scope.type === 'workspace')
+        return `workspace:${scope.workspaceId || '*'}`;
+    return 'global';
+}
+function scopeSpecificity(scope) {
+    if (scope.type === 'agent')
+        return 3;
+    if (scope.type === 'team')
+        return 2;
+    if (scope.type === 'workspace')
+        return 1;
+    return 0;
+}
+function scopeMatchesCaller(scope, caller) {
+    if (scope.type === 'global')
+        return true;
+    if (scope.workspaceId && scope.workspaceId !== caller.workspaceId)
+        return false;
+    if (scope.type === 'workspace')
+        return !!caller.workspaceId;
+    if (scope.teamId && scope.teamId !== caller.teamId)
+        return false;
+    if (scope.type === 'team')
+        return !!caller.workspaceId && !!caller.teamId;
+    if (scope.agentId && scope.agentId !== caller.agentId)
+        return false;
+    return !!caller.workspaceId && !!caller.teamId && !!caller.agentId;
+}
+function normalizeScopedPolicy(input, existing) {
+    const scope = normalizePolicyScope(input.scope);
+    const id = optionalString(input.id) || existing?.id || policyScopeId(scope);
+    return {
+        id,
+        scope,
+        pluginAllowlist: normalizedList(input.pluginAllowlist ?? existing?.pluginAllowlist),
+        pluginDenylist: normalizedList(input.pluginDenylist ?? existing?.pluginDenylist),
+        mcpServerAllowlist: normalizedList(input.mcpServerAllowlist ?? existing?.mcpServerAllowlist),
+        mcpServerDenylist: normalizedList(input.mcpServerDenylist ?? existing?.mcpServerDenylist),
+        mcpRegistryPolicy: input.mcpRegistryPolicy !== undefined
+            ? normalizeRegistryPolicy(input.mcpRegistryPolicy)
+            : existing?.mcpRegistryPolicy,
+        enabled: input.enabled ?? existing?.enabled ?? true,
+        updatedAt: numberTimestamp(input.updatedAt, existing?.updatedAt || Date.now()),
+    };
+}
+function listHas(list, value) {
+    const key = normalizePolicyKey(value);
+    return !!key && list.some((entry) => normalizePolicyKey(entry) === key);
+}
+function isAllowedByPolicyLists(value, allowlist, denylist) {
+    if (listHas(denylist, value))
+        return false;
+    if (allowlist.length > 0 && !listHas(allowlist, value))
+        return false;
+    return true;
+}
+function uniqueStrings(values) {
+    const seen = new Set();
+    const out = [];
+    for (const value of values) {
+        const trimmed = value.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        out.push(trimmed);
+    }
+    return out;
+}
+function mergeRemediation(values) {
+    const byCode = new Map();
+    for (const value of values) {
+        if (!byCode.has(value.code))
+            byCode.set(value.code, value);
+    }
+    return Array.from(byCode.values());
+}
+function remediation(code, label, description) {
+    return { code, label, description };
+}
+function createDenial(code, message, reasons, remediationItems) {
+    return {
+        code,
+        message,
+        reasons: uniqueStrings(reasons),
+        remediation: mergeRemediation(remediationItems),
+        safeForRenderer: true,
+    };
+}
+function trustRemediation(targetType, reasons) {
+    const text = reasons.join(' ').toLowerCase();
+    const items = [];
+    if (targetType === 'plugin') {
+        if (/not installed/.test(text))
+            items.push(remediation('install-plugin', 'Install plugin', 'Install the plugin before activating or exposing its tools.'));
+        if (/denied|blocked/.test(text))
+            items.push(remediation('approve-plugin', 'Approve plugin', 'Clear or approve the plugin trust decision after review.'));
+        if (/approval|review|unsigned|integrity|permission|changed/.test(text))
+            items.push(remediation('approve-plugin', 'Review plugin trust', 'Open Plugin Manager, review permissions, signature, and integrity, then approve if expected.'));
+    }
+    else {
+        if (/not configured/.test(text))
+            items.push(remediation('configure-mcp', 'Configure MCP server', 'Add or import the MCP server in Hub before using it.'));
+        if (/disabled/.test(text))
+            items.push(remediation('enable-mcp', 'Enable MCP server', 'Enable the MCP server and reload approved MCP connections.'));
+        if (/scoped policy|deny/.test(text))
+            items.push(remediation('remove-deny-policy', 'Adjust scoped policy', 'Remove the deny rule or add this MCP server to the caller allowlist.'));
+        if (/registry policy/.test(text))
+            items.push(remediation('adjust-registry-policy', 'Adjust exposure policy', 'Change the MCP registry exposure to include this access type.'));
+        if (/config changed|config hash|requires review/.test(text))
+            items.push(remediation('review-config-drift', 'Review config drift', 'Review the changed command, URL, env, headers, or scope, then re-approve the MCP server.'));
+        if (/approval|not trusted|requires hub approval|denied/.test(text))
+            items.push(remediation('approve-mcp', 'Approve MCP server', 'Approve the MCP server in Hub after reviewing its transport, command, and endpoint.'));
+    }
+    return mergeRemediation(items.length > 0 ? items : [remediation('retry', 'Retry after remediation', 'Resolve the denial reason and retry the request.')]);
+}
+function pluginToolName(tool) {
+    const record = tool && typeof tool === 'object' ? tool : {};
+    return optionalString(record.definition?.name) || optionalString(record.name);
+}
+function isNpmPackageName(name) {
+    return /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/.test(name);
+}
+function isMcpServerName(name) {
+    return /^[a-zA-Z0-9._-]{1,80}$/.test(name);
+}
+function isPathWithinAllowed(path, allowedDirectories) {
+    if (allowedDirectories.length === 0)
+        return false;
+    const resolved = resolve(path).toLowerCase().replace(/\\/g, '/');
+    return allowedDirectories.some((dir) => {
+        const allowed = resolve(dir).toLowerCase().replace(/\\/g, '/');
+        return resolved === allowed || resolved.startsWith(`${allowed}/`);
+    });
+}
+function hashJson(value) {
+    return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+function sortedStringRecord(value) {
+    return Object.fromEntries(Object.entries(value || {}).sort(([left], [right]) => left.localeCompare(right)));
+}
+function mcpApprovalConfig(record) {
+    return {
+        name: record.name,
+        transport: record.transport,
+        command: record.command,
+        args: record.args,
+        env: sortedStringRecord(record.env),
+        cwd: record.cwd,
+        url: record.url,
+        headers: sortedStringRecord(record.headers),
+        disabled: record.disabled,
+        scope: record.scope,
+        source: record.source,
+        sourcePath: record.sourcePath,
+        approvalKey: record.approvalKey,
+        approvalRequired: record.approvalRequired,
+    };
+}
+function mcpConfigHash(record) {
+    return hashJson(mcpApprovalConfig(record));
+}
+function analyzePluginTrust(plugin, trustFile) {
+    const manifest = plugin.manifest;
+    const manifestHash = hashJson(manifest);
+    const integrityHash = plugin.integrityHash;
+    const decision = trustFile?.plugins?.[normalizePolicyKey(manifest.name)];
+    const permissionText = [
+        ...stringArray(manifest.permissions),
+        ...stringArray(manifest.capabilities),
+    ].join(' ').toLowerCase();
+    const reasons = [];
+    const highRisk = /\b(shell|process|exec|filesystem|fs:write|storage:write|network|net|secrets|credentials)\b/.test(permissionText);
+    const mediumRisk = highRisk || /\b(tools:register|storage:read|panel|command|mcp)\b/.test(permissionText);
+    const signatureStatus = pluginSignatureStatus(plugin);
+    const riskLevel = highRisk ? 'high' : mediumRisk ? 'medium' : 'low';
+    if (signatureStatus !== 'verified')
+        reasons.push(signatureStatus === 'unsigned' ? 'Plugin manifest is unsigned.' : 'Plugin signature is present but not verified by Hub.');
+    if (highRisk)
+        reasons.push('Plugin requests high-risk permissions or capabilities.');
+    if (!integrityHash)
+        reasons.push('Plugin package integrity hash is missing.');
+    const trustDecisionHashMismatch = !!decision && (decision.manifestHash !== manifestHash
+        || (!!integrityHash && decision.integrityHash !== integrityHash));
+    const trustDecisionMatchesCurrent = !!decision
+        && decision.manifestHash === manifestHash
+        && (!integrityHash || decision.integrityHash === integrityHash);
+    if (trustDecisionHashMismatch)
+        reasons.push('Plugin manifest or integrity changed after local trust decision.');
+    if (decision?.decision === 'denied' && trustDecisionMatchesCurrent) {
+        return {
+            state: 'blocked',
+            riskLevel,
+            signatureStatus,
+            integrityHash,
+            manifestHash,
+            deniedAt: decision.updatedAt,
+            reasons: [...reasons, 'Plugin was denied by local trust policy.'],
+            requiresApproval: true,
+        };
+    }
+    const approved = decision?.decision === 'approved'
+        && trustDecisionMatchesCurrent;
+    const requiresApproval = trustDecisionHashMismatch || riskLevel !== 'low' || signatureStatus !== 'verified' || !integrityHash;
+    return {
+        state: approved || !requiresApproval ? 'trusted' : 'review-required',
+        riskLevel,
+        signatureStatus,
+        integrityHash,
+        manifestHash,
+        approvedAt: approved ? decision?.updatedAt : undefined,
+        reasons: reasons.length ? reasons : ['Plugin passed local trust checks.'],
+        requiresApproval: requiresApproval && !approved,
+    };
+}
+function pluginSignatureStatus(plugin) {
+    const record = plugin;
+    const manifest = plugin.manifest;
+    const signed = !!(record.signature
+        || record.signatures
+        || manifest.signature
+        || manifest.signatures
+        || manifest.publisherSignature);
+    if (record.signatureVerified === true || manifest.signatureVerified === true)
+        return 'verified';
+    return signed ? 'unknown' : 'unsigned';
+}
+function sanitizePluginInfo(plugin, trustFile) {
+    const manifest = plugin.manifest;
+    const trust = analyzePluginTrust(plugin, trustFile);
+    return {
+        name: manifest.name,
+        version: manifest.version,
+        description: manifest.description || '',
+        status: plugin.status,
+        installedAt: plugin.installedAt,
+        path: plugin.path,
+        capabilities: manifest.capabilities || [],
+        permissions: manifest.permissions || [],
+        tools: [
+            ...stringArray(manifest.tools),
+            ...stringArray(manifest.contributes?.tools?.map((tool) => tool.name)),
+            ...stringArray(plugin.registeredTools?.map(pluginToolName)),
+        ],
+        prompts: stringArray(manifest.contributes?.prompts?.map((prompt) => prompt.name)),
+        commands: stringArray(manifest.contributes?.commands?.map((command) => command.name)),
+        panels: stringArray(manifest.ui?.map((panel) => panel.id)),
+        keywords: stringArray(manifest.keywords),
+        error: plugin.error,
+        integrityHash: plugin.integrityHash,
+        trust,
+    };
+}
+function summarizeMcpTool(tool) {
+    return {
+        server: tool.server,
+        name: tool.name,
+        description: tool.description || '',
+        inputSchema: tool.inputSchema || {},
+    };
+}
+function summarizeMcpPrompt(prompt) {
+    return {
+        server: prompt.server,
+        name: prompt.name,
+        description: prompt.description || '',
+        arguments: Array.isArray(prompt.arguments) ? prompt.arguments : [],
+    };
+}
+function summarizeMcpResource(resource) {
+    return {
+        server: resource.server,
+        uri: resource.uri,
+        name: resource.name,
+        description: resource.description,
+        mimeType: resource.mimeType,
+    };
+}
+function mcpRecordFromConfig(config, sourcePath, source) {
+    const now = Date.now();
+    const scope = normalizeMcpScope(config.scope);
+    return {
+        name: config.name,
+        transport: config.transport || (config.url ? 'sse' : 'stdio'),
+        command: config.command,
+        args: stringArray(config.args),
+        env: stringRecord(config.env),
+        cwd: config.cwd,
+        url: config.url,
+        headers: stringRecord(config.headers),
+        approvalRequired: config.approvalRequired ?? true,
+        disabled: !!config.disabled,
+        scope,
+        source,
+        sourcePath,
+        approvalKey: config.approvalKey || `${scope}:${config.name}`,
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+function mcpRecordToConfig(record) {
+    return {
+        name: record.name,
+        transport: record.transport,
+        args: record.args,
+        env: record.env,
+        headers: record.headers,
+        approvalRequired: record.approvalRequired,
+        disabled: record.disabled,
+        scope: record.scope,
+        approvalKey: record.approvalKey,
+        ...(record.command !== undefined ? { command: record.command } : {}),
+        ...(record.cwd !== undefined ? { cwd: record.cwd } : {}),
+        ...(record.url !== undefined ? { url: record.url } : {}),
+        ...(record.approvalState !== undefined ? { approvalState: record.approvalState } : {}),
+        ...(record.sourcePath !== undefined ? { sourcePath: record.sourcePath } : {}),
+    };
+}
+function analyzeMcpTrust(record) {
+    const reasons = [];
+    const highRisk = record.transport === 'stdio';
+    const riskLevel = highRisk ? 'high' : 'medium';
+    const configHash = mcpConfigHash(record);
+    const approvalMatchesConfig = record.approvalConfigHash === configHash;
+    const approved = record.approvalState === 'approved' && approvalMatchesConfig;
+    const denied = record.approvalState === 'denied' && approvalMatchesConfig;
+    if (record.disabled)
+        reasons.push('MCP server is disabled.');
+    if (!approved)
+        reasons.push('MCP server requires Hub approval before tool calls.');
+    if (record.approvalState === 'approved' && !approvalMatchesConfig) {
+        reasons.push('MCP server config hash drift detected: approved configuration no longer matches the current command, URL, env, headers, or scope. Review and re-approve before use.');
+    }
+    if (denied)
+        reasons.push('MCP server was denied by local approval policy.');
+    if (record.approvalState === 'denied' && !approvalMatchesConfig) {
+        reasons.push('MCP server config hash drift detected after denial. Review the changed configuration before clearing or approving.');
+    }
+    if (record.transport === 'stdio')
+        reasons.push('stdio MCP servers execute a local process.');
+    if (record.transport === 'sse')
+        reasons.push('SSE MCP servers communicate with a remote endpoint.');
+    return {
+        state: record.disabled || denied
+            ? 'blocked'
+            : !approved
+                ? 'review-required'
+                : 'trusted',
+        riskLevel,
+        signatureStatus: 'unknown',
+        manifestHash: configHash,
+        approvedConfigHash: record.approvalConfigHash,
+        currentConfigHash: configHash,
+        configDrift: !!record.approvalConfigHash && !approvalMatchesConfig,
+        approvedAt: approved ? record.updatedAt : undefined,
+        deniedAt: denied ? record.updatedAt : undefined,
+        reasons: reasons.length ? reasons : ['MCP server approved by local policy.'],
+        requiresApproval: !approved,
+    };
+}
+export function createResultPreview(result, title, source = 'mcp-tool') {
+    const extracted = extractPreviewText(result);
+    const byteLength = Buffer.byteLength(extracted.text, 'utf-8');
+    const truncated = byteLength > MAX_PREVIEW_BYTES;
+    const textPreview = truncated
+        ? extracted.text.slice(0, MAX_PREVIEW_BYTES) + '\n...[truncated]'
+        : extracted.text;
+    const previewByteLength = Buffer.byteLength(textPreview, 'utf-8');
+    const resultHash = createHash('sha256').update(extracted.text).digest('hex');
+    return {
+        kind: extracted.kind,
+        title,
+        textPreview,
+        byteLength,
+        itemCount: extracted.itemCount,
+        truncated,
+        metadata: {
+            safeForRenderer: true,
+            generatedAt: new Date().toISOString(),
+            source,
+            contentTypes: uniqueStrings(extracted.contentTypes),
+            redacted: extracted.redactedFields.length > 0,
+            redactedFields: uniqueStrings(extracted.redactedFields).sort(),
+            riskWarnings: uniqueStrings(extracted.riskWarnings),
+            originalByteLength: byteLength,
+            previewByteLength,
+            maxPreviewBytes: MAX_PREVIEW_BYTES,
+            resultHash,
+            copyAllowed: extracted.kind !== 'binary',
+            attachAllowed: extracted.kind !== 'binary' && extracted.riskWarnings.length === 0,
+        },
+    };
+}
+function extractPreviewText(value) {
+    const record = value && typeof value === 'object' ? value : {};
+    const content = Array.isArray(record.content) ? record.content : undefined;
+    const contents = Array.isArray(record.contents) ? record.contents : undefined;
+    const messages = Array.isArray(record.messages) ? record.messages : undefined;
+    if (content) {
+        const parts = [];
+        let hasBinary = false;
+        const contentTypes = [];
+        const redactedFields = [];
+        const riskWarnings = [];
+        for (const item of content) {
+            const entry = item && typeof item === 'object' ? item : {};
+            if (typeof entry.mimeType === 'string')
+                contentTypes.push(entry.mimeType);
+            if (typeof entry.type === 'string')
+                contentTypes.push(entry.type);
+            if (typeof entry.text === 'string') {
+                const redacted = redactPreviewText(entry.text, 'content.text');
+                parts.push(redacted.text);
+                redactedFields.push(...redacted.fields);
+                riskWarnings.push(...redacted.warnings);
+            }
+            else if (typeof entry.uri === 'string')
+                parts.push(entry.uri);
+            else {
+                hasBinary = true;
+                const redacted = redactPreviewValue(entry);
+                parts.push(JSON.stringify(redacted.value).slice(0, 1000));
+                redactedFields.push(...redacted.fields);
+            }
+        }
+        return {
+            kind: hasBinary && parts.length > 0 ? 'mixed' : hasBinary ? 'binary' : parts.length > 0 ? 'text' : 'empty',
+            text: parts.join('\n\n'),
+            itemCount: content.length,
+            contentTypes: contentTypes.length ? contentTypes : ['text/plain'],
+            redactedFields,
+            riskWarnings,
+        };
+    }
+    if (contents) {
+        const parts = [];
+        let hasBinary = false;
+        const contentTypes = [];
+        const redactedFields = [];
+        const riskWarnings = [];
+        for (const item of contents) {
+            const entry = item && typeof item === 'object' ? item : {};
+            if (typeof entry.mimeType === 'string')
+                contentTypes.push(entry.mimeType);
+            if (typeof entry.text === 'string') {
+                const redacted = redactPreviewText(entry.text, 'contents.text');
+                parts.push(redacted.text);
+                redactedFields.push(...redacted.fields);
+                riskWarnings.push(...redacted.warnings);
+            }
+            else if (typeof entry.blob === 'string') {
+                hasBinary = true;
+                contentTypes.push('application/octet-stream');
+                parts.push(`[binary blob: ${Buffer.byteLength(entry.blob, 'utf-8')} encoded bytes]`);
+            }
+            else if (typeof entry.uri === 'string') {
+                parts.push(entry.uri);
+            }
+        }
+        return {
+            kind: hasBinary && parts.length > 0 ? 'mixed' : hasBinary ? 'binary' : parts.length > 0 ? 'text' : 'empty',
+            text: parts.join('\n\n'),
+            itemCount: contents.length,
+            contentTypes: contentTypes.length ? contentTypes : ['text/plain'],
+            redactedFields,
+            riskWarnings,
+        };
+    }
+    if (messages) {
+        const parts = [];
+        const contentTypes = [];
+        const redactedFields = [];
+        const riskWarnings = [];
+        for (const item of messages) {
+            const entry = item && typeof item === 'object' ? item : {};
+            const role = typeof entry.role === 'string' ? entry.role : 'message';
+            if (typeof entry.content === 'string') {
+                const redacted = redactPreviewText(entry.content, `messages.${role}`);
+                parts.push(`${role}: ${redacted.text}`);
+                redactedFields.push(...redacted.fields);
+                riskWarnings.push(...redacted.warnings);
+                contentTypes.push('text/plain');
+            }
+            else {
+                const redacted = redactPreviewValue(entry.content);
+                parts.push(`${role}: ${JSON.stringify(redacted.value)}`);
+                redactedFields.push(...redacted.fields.map((field) => `messages.${role}.${field}`));
+                contentTypes.push('application/json');
+            }
+        }
+        return {
+            kind: parts.length > 0 ? 'text' : 'empty',
+            text: parts.join('\n\n'),
+            itemCount: messages.length,
+            contentTypes,
+            redactedFields,
+            riskWarnings,
+        };
+    }
+    const redacted = redactPreviewValue(value);
+    const json = JSON.stringify(redacted.value, null, 2);
+    return {
+        kind: json && json !== 'undefined' ? 'json' : 'empty',
+        text: json && json !== 'undefined' ? json : '',
+        itemCount: Array.isArray(value) ? value.length : value === undefined || value === null ? 0 : 1,
+        contentTypes: json && json !== 'undefined' ? ['application/json'] : [],
+        redactedFields: redacted.fields,
+        riskWarnings: [],
+    };
+}
+function redactPreviewText(value, field) {
+    const fields = [];
+    const warnings = [];
+    let text = value;
+    const patterns = [
+        [/\b(Bearer\s+)[A-Za-z0-9._~+/=-]{16,}/gi, '$1[redacted]'],
+        [/\b(sk-[A-Za-z0-9_-]{16,})\b/g, '[redacted]'],
+        [/\b([A-Z0-9_]*(?:TOKEN|SECRET|PASSWORD|API_KEY|AUTHORIZATION)[A-Z0-9_]*\s*[:=]\s*)(["']?)[^\s"',;]{6,}\2/gi, '$1[redacted]'],
+    ];
+    for (const [pattern, replacement] of patterns) {
+        if (pattern.test(text)) {
+            fields.push(field);
+            text = text.replace(pattern, replacement);
+        }
+    }
+    if (/\b(ignore (all )?(previous|prior) instructions|system prompt|developer message|exfiltrate|send (the )?secrets?)\b/i.test(value)) {
+        warnings.push('MCP output contains prompt-injection language. Review before attaching to an agent context.');
+    }
+    return { text, fields, warnings };
+}
+function redactPreviewValue(value, path = '') {
+    if (Array.isArray(value)) {
+        const fields = [];
+        const entries = value.map((entry, index) => {
+            const redacted = redactPreviewValue(entry, `${path}[${index}]`);
+            fields.push(...redacted.fields);
+            return redacted.value;
+        });
+        return { value: entries, fields };
+    }
+    if (!value || typeof value !== 'object')
+        return { value, fields: [] };
+    const out = {};
+    const fields = [];
+    for (const [key, entry] of Object.entries(value)) {
+        const childPath = path ? `${path}.${key}` : key;
+        if (/token|secret|password|cookie|authorization|api[-_]?key/i.test(key)) {
+            out[key] = '[redacted]';
+            fields.push(childPath);
+        }
+        else {
+            const redacted = redactPreviewValue(entry, childPath);
+            out[key] = redacted.value;
+            fields.push(...redacted.fields);
+        }
+    }
+    return { value: out, fields };
+}
+export class PluginMcpManagerService {
+    baseDir;
+    pluginDir;
+    pluginEventLogPath;
+    pluginTrustPath;
+    mcpDir;
+    mcpServersPath;
+    mcpApprovalsPath;
+    pluginHost = null;
+    mcpManager = null;
+    mcpUnsubscribe = null;
+    pluginEvents = [];
+    activePluginsHydrated = false;
+    constructor(baseDir = join(homedir(), '.xeno')) {
+        this.baseDir = baseDir;
+        this.pluginDir = join(baseDir, 'plugins');
+        this.pluginEventLogPath = join(this.pluginDir, 'events.jsonl');
+        this.pluginTrustPath = join(this.pluginDir, 'trust.json');
+        this.mcpDir = join(baseDir, 'mcp');
+        this.mcpServersPath = join(this.mcpDir, 'servers.json');
+        this.mcpApprovalsPath = join(this.mcpDir, 'approvals.jsonl');
+        ensureDir(this.pluginDir);
+        ensureDir(this.mcpDir);
+        this.pluginEvents = this.loadPluginEvents();
+    }
+    async snapshot(request = {}) {
+        const host = await this.getPluginHost();
+        const manager = await this.getMcpManager();
+        const file = this.readMcpFile();
+        const trustFile = this.readPluginTrustFile();
+        const caller = normalizeCaller(request);
+        const effectivePolicy = this.resolveEffectivePolicy(caller, file);
+        const installed = host.listInstalled();
+        const plugins = installed.map((plugin) => sanitizePluginInfo(plugin, trustFile));
+        const activePluginTools = installed
+            .filter((plugin) => {
+            const trust = analyzePluginTrust(plugin, trustFile);
+            return plugin.status === 'active' && trust.state === 'trusted' && this.isPluginAllowed(plugin.manifest.name, effectivePolicy);
+        })
+            .flatMap((plugin) => [
+            ...stringArray(plugin.manifest.tools),
+            ...stringArray(plugin.manifest.contributes?.tools?.map((tool) => tool.name)),
+            ...stringArray(plugin.registeredTools?.map(pluginToolName)),
+        ]);
+        const configured = await this.listConfiguredMcpRecords(request);
+        const runtimeStates = manager.listServers();
+        const mcpServers = this.mergeMcpServerSummaries(configured, runtimeStates, manager);
+        const mcpTools = manager.listTools().map(summarizeMcpTool);
+        const mcpPrompts = manager.listPrompts().map(summarizeMcpPrompt);
+        const mcpResources = manager.listResources().map(summarizeMcpResource);
+        const activePluginCount = plugins.filter((plugin) => plugin.status === 'active').length;
+        return {
+            plugins,
+            pluginEvents: this.pluginEvents.slice(-MAX_PLUGIN_EVENTS),
+            activePluginTools,
+            mcpServers,
+            mcpTools,
+            mcpPrompts,
+            mcpResources,
+            mcpRegistryPolicy: file.registryPolicy,
+            scopedPolicies: file.scopedPolicies,
+            effectivePolicy,
+            stats: {
+                pluginCount: plugins.length,
+                activePluginCount,
+                activePluginToolCount: activePluginTools.length,
+                mcpServerCount: mcpServers.length,
+                connectedMcpServerCount: mcpServers.filter((server) => server.status === 'ready').length,
+                mcpToolCount: mcpTools.length,
+                mcpPromptCount: mcpPrompts.length,
+                mcpResourceCount: mcpResources.length,
+            },
+        };
+    }
+    async installPlugin(request) {
+        try {
+            const packageName = normalizeSearchText(request.packageName);
+            if (!packageName || !isNpmPackageName(packageName)) {
+                return { success: false, error: 'Invalid npm package name.' };
+            }
+            const host = await this.getPluginHost();
+            const info = await host.install(packageName, optionalString(request.version));
+            return { success: info.status !== 'error', plugin: sanitizePluginInfo(info, this.readPluginTrustFile()), error: info.error };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async installLocalPlugin(request) {
+        try {
+            const pluginPath = optionalString(request.pluginPath);
+            if (!pluginPath)
+                return { success: false, error: 'Plugin path is required.' };
+            const allowed = stringArray(request.caller?.allowedDirectories);
+            if (allowed.length > 0 && !isPathWithinAllowed(pluginPath, allowed)) {
+                return { success: false, error: 'Plugin path is outside the caller allowed directories.' };
+            }
+            const host = await this.getPluginHost();
+            const info = await host.installLocal(resolve(pluginPath));
+            return { success: true, plugin: sanitizePluginInfo(info, this.readPluginTrustFile()) };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async activatePlugin(request) {
+        return this.withPlugin(request.name, async (host, name) => {
+            const before = host.getPlugin(name);
+            if (!before)
+                return { success: false, error: `Plugin "${name}" is not installed.` };
+            const trust = analyzePluginTrust(before, this.readPluginTrustFile());
+            if (trust.state !== 'trusted') {
+                return { success: false, plugin: sanitizePluginInfo(before, this.readPluginTrustFile()), error: `Plugin "${name}" requires trust approval before activation: ${trust.reasons.join(' ')}` };
+            }
+            await host.activate(name);
+            const plugin = host.getPlugin(name);
+            return { success: !!plugin && plugin.status !== 'error', plugin: plugin ? sanitizePluginInfo(plugin, this.readPluginTrustFile()) : undefined, error: plugin?.error };
+        });
+    }
+    async deactivatePlugin(request) {
+        return this.withPlugin(request.name, async (host, name) => {
+            await host.deactivate(name);
+            const plugin = host.getPlugin(name);
+            return { success: true, plugin: plugin ? sanitizePluginInfo(plugin, this.readPluginTrustFile()) : undefined };
+        });
+    }
+    async uninstallPlugin(request) {
+        try {
+            const name = normalizeSearchText(request.name);
+            if (!name)
+                return { success: false, error: 'Plugin name is required.' };
+            const host = await this.getPluginHost();
+            const removed = await host.uninstall(name, request.removeFiles ?? false);
+            return removed ? { success: true } : { success: false, error: `Plugin "${name}" is not installed.` };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async updatePlugin(request) {
+        return this.withPlugin(request.name, async (host, name) => {
+            const info = await host.update(name, optionalString(request.version));
+            return { success: info.status !== 'error', plugin: sanitizePluginInfo(info, this.readPluginTrustFile()), error: info.error };
+        });
+    }
+    async setPluginTrust(request) {
+        return this.withPlugin(request.name, async (host, name) => {
+            const plugin = host.getPlugin(name);
+            if (!plugin)
+                return { success: false, error: `Plugin "${name}" is not installed.` };
+            const file = this.readPluginTrustFile();
+            const key = normalizePolicyKey(name);
+            if (request.decision === 'cleared') {
+                delete file.plugins[key];
+            }
+            else {
+                file.plugins[key] = {
+                    decision: request.decision === 'approved' ? 'approved' : 'denied',
+                    manifestHash: hashJson(plugin.manifest),
+                    integrityHash: plugin.integrityHash,
+                    updatedAt: Date.now(),
+                };
+            }
+            this.writePluginTrustFile(file);
+            if (request.decision === 'denied' && plugin.status === 'active') {
+                await host.deactivate(name);
+            }
+            this.appendMcpApproval({
+                type: 'plugin-trust.decision',
+                targetType: 'plugin',
+                name,
+                decision: request.decision,
+                manifestHash: hashJson(plugin.manifest),
+                integrityHash: plugin.integrityHash,
+                riskLevel: analyzePluginTrust(plugin, file).riskLevel,
+                actor: normalizeCaller(request.caller),
+                reason: optionalString(request.reason),
+                timestamp: new Date().toISOString(),
+            });
+            const current = host.getPlugin(name) || plugin;
+            return { success: true, plugin: sanitizePluginInfo(current, file) };
+        });
+    }
+    async upsertMcpServer(request) {
+        try {
+            const server = this.normalizeHubMcpServer(request.server);
+            const file = this.readMcpFile();
+            const existing = file.servers.find((entry) => entry.name === server.name);
+            const next = existing
+                ? {
+                    ...existing,
+                    ...server,
+                    approvalState: existing.approvalState,
+                    approvalConfigHash: existing.approvalConfigHash,
+                    createdAt: existing.createdAt,
+                    updatedAt: Date.now(),
+                }
+                : server;
+            if (existing && mcpConfigHash(existing) !== mcpConfigHash(next)) {
+                next.approvalState = undefined;
+                next.approvalConfigHash = undefined;
+                const manager = await this.getMcpManager();
+                manager.removeServer(next.name);
+            }
+            file.servers = [
+                ...file.servers.filter((entry) => entry.name !== server.name),
+                next,
+            ].sort((left, right) => left.name.localeCompare(right.name));
+            this.writeMcpFile(file);
+            return { success: true, server: next };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async removeMcpServer(request) {
+        try {
+            const name = normalizeSearchText(request.name);
+            if (!name)
+                return { success: false, error: 'MCP server name is required.' };
+            const manager = await this.getMcpManager();
+            manager.removeServer(name);
+            const file = this.readMcpFile();
+            file.servers = file.servers.filter((entry) => entry.name !== name);
+            this.writeMcpFile(file);
+            return { success: true };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async setMcpApproval(request) {
+        try {
+            const name = normalizeSearchText(request.name);
+            if (!name)
+                return { success: false, error: 'MCP server name is required.' };
+            const file = this.readMcpFile();
+            const server = file.servers.find((entry) => entry.name === name);
+            if (!server)
+                return { success: false, error: `MCP server "${name}" is not configured in Hub.` };
+            const previousDecision = server.approvalState;
+            const previousConfigHash = server.approvalConfigHash;
+            const currentConfigHash = mcpConfigHash(server);
+            const configDrift = !!previousConfigHash && previousConfigHash !== currentConfigHash;
+            server.approvalState = request.decision;
+            if (request.decision === 'approved' || request.decision === 'denied') {
+                server.approvalConfigHash = mcpConfigHash(server);
+            }
+            else {
+                server.approvalConfigHash = undefined;
+            }
+            server.updatedAt = Date.now();
+            this.writeMcpFile(file);
+            if (request.decision !== 'approved') {
+                const manager = await this.getMcpManager();
+                manager.removeServer(name);
+            }
+            this.appendMcpApproval({
+                type: 'mcp-approval.decision',
+                targetType: 'mcp',
+                name,
+                approvalKey: server.approvalKey,
+                previousDecision,
+                decision: request.decision || 'cleared',
+                previousConfigHash,
+                currentConfigHash,
+                configHash: server.approvalConfigHash,
+                configDrift,
+                transport: server.transport,
+                source: server.source,
+                sourcePath: server.sourcePath,
+                actor: normalizeCaller(request.caller),
+                reason: optionalString(request.reason),
+                timestamp: new Date().toISOString(),
+            });
+            return { success: true, server };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async reloadMcp(request = {}) {
+        const connected = [];
+        const skipped = [];
+        const errors = [];
+        try {
+            this.disposeMcpManager();
+            const manager = await this.getMcpManager();
+            const configured = await this.listConfiguredMcpRecords({ cwd: request.cwd, includeSdkConfigured: true });
+            const file = this.readMcpFile();
+            const effectivePolicy = this.resolveEffectivePolicy(normalizeCaller(request), file);
+            if (request.connect) {
+                for (const server of configured) {
+                    if (!this.isMcpServerAllowed(server.name, effectivePolicy)) {
+                        skipped.push(server.name);
+                        continue;
+                    }
+                    if (server.disabled) {
+                        skipped.push(server.name);
+                        continue;
+                    }
+                    if (analyzeMcpTrust(server).state !== 'trusted') {
+                        skipped.push(server.name);
+                        continue;
+                    }
+                    try {
+                        await manager.addServer(mcpRecordToConfig(server));
+                        connected.push(server.name);
+                    }
+                    catch (err) {
+                        errors.push({ name: server.name, error: err instanceof Error ? err.message : String(err) });
+                    }
+                }
+            }
+            else {
+                skipped.push(...configured.map((server) => server.name));
+            }
+            return { success: errors.length === 0, snapshot: await this.snapshot({ cwd: request.cwd, includeSdkConfigured: true, ...normalizeCaller(request) }), connected, skipped, errors };
+        }
+        catch (err) {
+            return { success: false, connected, skipped, errors, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async setMcpRegistryPolicy(request) {
+        try {
+            const file = this.readMcpFile();
+            file.registryPolicy = normalizeRegistryPolicy(request.policy);
+            this.writeMcpFile(file);
+            return { success: true, snapshot: await this.snapshot() };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async setScopedPolicy(request) {
+        try {
+            const file = this.readMcpFile();
+            const scope = normalizePolicyScope(request.policy?.scope);
+            const id = optionalString(request.policy?.id) || policyScopeId(scope);
+            const existing = file.scopedPolicies.find((entry) => entry.id === id || policyScopeId(entry.scope) === policyScopeId(scope));
+            const policy = normalizeScopedPolicy({ ...request.policy, id, scope }, existing);
+            policy.updatedAt = Date.now();
+            file.scopedPolicies = [
+                ...file.scopedPolicies.filter((entry) => entry.id !== policy.id && policyScopeId(entry.scope) !== policyScopeId(policy.scope)),
+                policy,
+            ].sort((left, right) => scopeSpecificity(left.scope) - scopeSpecificity(right.scope) || left.id.localeCompare(right.id));
+            this.writeMcpFile(file);
+            return { success: true, policy, snapshot: await this.snapshot() };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async deleteScopedPolicy(request) {
+        try {
+            const file = this.readMcpFile();
+            const id = optionalString(request.id);
+            const scopeId = request.scope ? policyScopeId(normalizePolicyScope(request.scope)) : undefined;
+            if (!id && !scopeId)
+                return { success: false, error: 'Policy id or scope is required.' };
+            const before = file.scopedPolicies.length;
+            file.scopedPolicies = file.scopedPolicies.filter((policy) => policy.id !== id && policyScopeId(policy.scope) !== scopeId);
+            if (file.scopedPolicies.length === before)
+                return { success: false, error: 'Scoped policy was not found.' };
+            this.writeMcpFile(file);
+            return { success: true, snapshot: await this.snapshot() };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async searchMarketplace(request = {}) {
+        try {
+            const sdk = await loadSdk();
+            const registry = optionalString(request.registry);
+            const marketplace = new sdk.PluginMarketplace({
+                timeout: 8000,
+                ...(registry !== undefined ? { registry } : {}),
+            });
+            const query = optionalString(request.query);
+            const keyword = optionalString(request.keyword);
+            const listings = await marketplace.search({
+                limit: typeof request.limit === 'number' ? Math.max(1, Math.min(request.limit, 50)) : 20,
+                offset: typeof request.offset === 'number' ? Math.max(0, request.offset) : 0,
+                verifiedOnly: request.verifiedOnly === true,
+                ...(query !== undefined ? { query } : {}),
+                ...(keyword !== undefined ? { keyword } : {}),
+                ...(request.capability !== undefined ? { capability: request.capability } : {}),
+                ...(request.sortBy !== undefined ? { sortBy: request.sortBy } : {}),
+            });
+            return { success: true, listings };
+        }
+        catch (err) {
+            return { success: false, listings: [], error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async syncProjectMcp(request) {
+        const direction = request.direction === 'export' ? 'export' : 'import';
+        try {
+            const cwd = optionalString(request.cwd);
+            if (!cwd)
+                return { success: false, direction, synced: 0, servers: [], error: 'Project cwd is required.' };
+            const caller = normalizeCaller(request.caller);
+            if (caller.allowedDirectories && caller.allowedDirectories.length > 0 && !isPathWithinAllowed(cwd, caller.allowedDirectories)) {
+                return { success: false, direction, synced: 0, servers: [], error: 'Project cwd is outside the caller allowed directories.' };
+            }
+            const projectCwd = resolve(cwd);
+            const sdk = await loadSdk();
+            const configPath = join(projectCwd, '.xeno', 'mcp.json');
+            const selectedNames = new Set(stringArray(request.serverNames).map((name) => normalizePolicyKey(name)));
+            if (direction === 'import') {
+                const config = sdk.loadMcpConfigFile(configPath, 'project');
+                const imported = Object.entries(config.mcpServers || {})
+                    .map(([name, server]) => mcpRecordFromConfig({
+                    ...server,
+                    name,
+                    scope: 'project',
+                    sourcePath: configPath,
+                    approvalKey: `project:${name}`,
+                }, configPath, 'hub'))
+                    .filter((server) => selectedNames.size === 0 || selectedNames.has(normalizePolicyKey(server.name)));
+                const file = this.readMcpFile();
+                const existingByName = new Map(file.servers.map((server) => [server.name, server]));
+                for (const server of imported) {
+                    const existing = existingByName.get(server.name);
+                    const next = {
+                        ...(existing || server),
+                        ...server,
+                        source: 'hub',
+                        createdAt: existing?.createdAt || server.createdAt,
+                        updatedAt: Date.now(),
+                    };
+                    if (existing && mcpConfigHash(existing) !== mcpConfigHash(next)) {
+                        next.approvalState = undefined;
+                        next.approvalConfigHash = undefined;
+                        const manager = await this.getMcpManager();
+                        manager.removeServer(next.name);
+                    }
+                    existingByName.set(server.name, next);
+                }
+                file.servers = Array.from(existingByName.values());
+                this.writeMcpFile(file);
+                return {
+                    success: true,
+                    direction,
+                    configPath,
+                    synced: imported.length,
+                    servers: imported,
+                    snapshot: await this.snapshot({ cwd: projectCwd, includeSdkConfigured: true, ...caller }),
+                };
+            }
+            const file = this.readMcpFile();
+            const effective = this.resolveEffectivePolicy(caller, file);
+            const exported = file.servers
+                .filter((server) => selectedNames.size === 0 || selectedNames.has(normalizePolicyKey(server.name)))
+                .filter((server) => this.isMcpServerAllowed(server.name, effective));
+            const written = [];
+            for (const server of exported) {
+                const { sourcePath: _sourcePath, ...exportableConfig } = mcpRecordToConfig(server);
+                const config = {
+                    ...exportableConfig,
+                    scope: 'project',
+                    approvalKey: `project:${server.name}`,
+                };
+                sdk.upsertMcpServerConfig('project', projectCwd, config);
+                written.push({ ...server, scope: 'project', sourcePath: configPath, approvalKey: `project:${server.name}`, updatedAt: Date.now() });
+            }
+            return {
+                success: true,
+                direction,
+                configPath,
+                synced: written.length,
+                servers: written,
+                snapshot: await this.snapshot({ cwd: projectCwd, includeSdkConfigured: true, ...caller }),
+            };
+        }
+        catch (err) {
+            return { success: false, direction, synced: 0, servers: [], error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async callMcpTool(request) {
+        try {
+            this.assertMcpServerUsable(request.serverName, request.caller, 'tool');
+            const manager = await this.getMcpManager();
+            const result = await manager.callTool(request.serverName, request.toolName, request.input || {});
+            const preview = createResultPreview(result, `${request.serverName}.${request.toolName}`, 'mcp-tool');
+            const auditId = this.recordMcpCallAudit('tool', request.serverName, request.toolName, preview);
+            return { success: true, result, preview, auditId };
+        }
+        catch (err) {
+            if (err instanceof PluginMcpDeniedError)
+                return { success: false, error: err.denial.message, denial: err.denial };
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async getMcpPrompt(request) {
+        try {
+            this.assertMcpServerUsable(request.serverName, request.caller, 'prompt');
+            const manager = await this.getMcpManager();
+            const result = await manager.getPrompt(request.serverName, request.promptName, request.input);
+            const preview = createResultPreview(result, `${request.serverName}.${request.promptName}`, 'mcp-prompt');
+            const auditId = this.recordMcpCallAudit('prompt', request.serverName, request.promptName, preview);
+            return { success: true, result, preview, auditId };
+        }
+        catch (err) {
+            if (err instanceof PluginMcpDeniedError)
+                return { success: false, error: err.denial.message, denial: err.denial };
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async readMcpResource(request) {
+        try {
+            this.assertMcpServerUsable(request.serverName, request.caller, 'resource');
+            const manager = await this.getMcpManager();
+            const result = await manager.readResource(request.serverName, request.uri);
+            const preview = createResultPreview(result, `${request.serverName}:${request.uri}`, 'mcp-resource');
+            const auditId = this.recordMcpCallAudit('resource', request.serverName, request.uri, preview);
+            return { success: true, result, preview, auditId };
+        }
+        catch (err) {
+            if (err instanceof PluginMcpDeniedError)
+                return { success: false, error: err.denial.message, denial: err.denial };
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async preflightTrust(request = {}) {
+        try {
+            const reasons = [];
+            const remediationItems = [];
+            const checks = [];
+            let allowed = true;
+            let pluginSummary;
+            let serverSummary;
+            const pluginName = optionalString(request.pluginName);
+            if (pluginName) {
+                let policyAllowed = true;
+                const checkReasons = [];
+                const host = await this.getPluginHost();
+                const plugin = host.getPlugin(pluginName);
+                if (!plugin) {
+                    allowed = false;
+                    checkReasons.push(`Plugin "${pluginName}" is not installed.`);
+                }
+                else {
+                    pluginSummary = sanitizePluginInfo(plugin, this.readPluginTrustFile());
+                    if (pluginSummary.trust.state !== 'trusted') {
+                        allowed = false;
+                        checkReasons.push(...pluginSummary.trust.reasons);
+                    }
+                }
+                const file = this.readMcpFile();
+                const effective = this.resolveEffectivePolicy(normalizeCaller(request.caller), file);
+                if (!this.isPluginAllowed(pluginName, effective)) {
+                    allowed = false;
+                    policyAllowed = false;
+                    checkReasons.push(`Plugin "${pluginName}" is denied by scoped policy.`);
+                }
+                const checkRemediation = trustRemediation('plugin', checkReasons);
+                reasons.push(...checkReasons);
+                remediationItems.push(...checkRemediation);
+                checks.push({
+                    targetType: 'plugin',
+                    targetName: pluginName,
+                    allowed: checkReasons.length === 0,
+                    policyAllowed,
+                    trustState: pluginSummary?.trust.state,
+                    configHash: pluginSummary?.trust.manifestHash,
+                    reasons: checkReasons,
+                    remediation: checkRemediation,
+                });
+            }
+            const mcpServerName = optionalString(request.mcpServerName);
+            if (mcpServerName) {
+                let policyAllowed = true;
+                const checkReasons = [];
+                const file = this.readMcpFile();
+                const server = file.servers.find((entry) => entry.name === mcpServerName);
+                if (!server) {
+                    allowed = false;
+                    checkReasons.push(`MCP server "${mcpServerName}" is not configured in Hub.`);
+                }
+                else {
+                    const manager = await this.getMcpManager();
+                    const state = manager.listServers().find((entry) => entry.config.name === mcpServerName);
+                    serverSummary = this.mcpServerSummary(server, state, manager);
+                    const effective = this.resolveEffectivePolicy(normalizeCaller(request.caller), file);
+                    if (!this.isMcpServerAllowed(mcpServerName, effective)) {
+                        allowed = false;
+                        policyAllowed = false;
+                        checkReasons.push(`MCP server "${mcpServerName}" is denied by scoped policy.`);
+                    }
+                    if (serverSummary.trust.state !== 'trusted') {
+                        allowed = false;
+                        checkReasons.push(...serverSummary.trust.reasons);
+                    }
+                }
+                const checkRemediation = trustRemediation('mcp', checkReasons);
+                reasons.push(...checkReasons);
+                remediationItems.push(...checkRemediation);
+                checks.push({
+                    targetType: 'mcp',
+                    targetName: mcpServerName,
+                    allowed: checkReasons.length === 0,
+                    policyAllowed,
+                    trustState: serverSummary?.trust.state,
+                    configHash: serverSummary?.trust.currentConfigHash || serverSummary?.trust.manifestHash,
+                    approvedConfigHash: serverSummary?.trust.approvedConfigHash,
+                    configDrift: serverSummary?.trust.configDrift,
+                    reasons: checkReasons,
+                    remediation: checkRemediation,
+                });
+            }
+            const finalReasons = reasons.length ? uniqueStrings(reasons) : ['Trust preflight passed.'];
+            const finalRemediation = allowed ? [] : mergeRemediation(remediationItems);
+            const target = pluginName && mcpServerName
+                ? { type: 'combined', name: `${pluginName}+${mcpServerName}` }
+                : pluginName
+                    ? { type: 'plugin', name: pluginName }
+                    : mcpServerName
+                        ? { type: 'mcp', name: mcpServerName }
+                        : undefined;
+            return {
+                success: true,
+                allowed,
+                target,
+                checks,
+                plugin: pluginSummary,
+                server: serverSummary,
+                reasons: finalReasons,
+                remediation: finalRemediation,
+                denial: allowed ? undefined : createDenial('plugin-mcp-preflight-denied', 'Plugin/MCP trust preflight denied the request.', finalReasons, finalRemediation),
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                allowed: false,
+                checks: [],
+                reasons: [],
+                remediation: [remediation('retry', 'Retry', 'Retry after Plugin/MCP state is available.')],
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    async registerRuntimeTools(toolRegistry, options = {}) {
+        const errors = [];
+        const pluginTools = [];
+        const mcpTools = [];
+        const file = this.readMcpFile();
+        const effectivePolicy = this.resolveEffectivePolicy(normalizeCaller(options), file);
+        if (options.includePlugins !== false) {
+            try {
+                const host = await this.getPluginHost();
+                const trustFile = this.readPluginTrustFile();
+                for (const plugin of host.listInstalled()) {
+                    if (plugin.status !== 'active' || !this.isPluginAllowed(plugin.manifest.name, effectivePolicy))
+                        continue;
+                    const trust = analyzePluginTrust(plugin, trustFile);
+                    if (trust.state !== 'trusted') {
+                        try {
+                            await host.deactivate(plugin.manifest.name);
+                        }
+                        catch { /* best-effort trust quarantine */ }
+                        continue;
+                    }
+                    for (const tool of plugin.registeredTools || []) {
+                        const name = pluginToolName(tool);
+                        if (!name)
+                            continue;
+                        toolRegistry.register(tool);
+                        pluginTools.push(name);
+                    }
+                }
+            }
+            catch (err) {
+                errors.push(`PluginHost: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        if (options.includeMcp !== false) {
+            try {
+                const sdk = await loadSdk();
+                const manager = await this.getMcpManager();
+                if (manager.listServers().length === 0) {
+                    const reload = await this.reloadMcp({ connect: true, cwd: options.cwd, ...normalizeCaller(options) });
+                    for (const error of reload.errors)
+                        errors.push(`MCP ${error.name}: ${error.error}`);
+                    if (reload.error)
+                        errors.push(`MCP reload: ${reload.error}`);
+                }
+                const registered = sdk.syncMcpToolsToRegistry(manager, toolRegistry, [], (entry) => this.isMcpServerAllowed(entry.server, effectivePolicy)
+                    && this.isMcpServerTrusted(entry.server)
+                    && sdk.matchesMcpRegistryEntryPolicy(entry, effectivePolicy.mcpRegistryPolicy));
+                mcpTools.push(...registered);
+            }
+            catch (err) {
+                errors.push(`MCP: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        return { pluginTools, mcpTools, errors };
+    }
+    toSearchDocuments() {
+        const documents = [];
+        const pluginRegistry = safeReadJson(join(this.pluginDir, 'plugins.json'), { plugins: {} });
+        const trustFile = this.readPluginTrustFile();
+        for (const [key, plugin] of Object.entries(pluginRegistry.plugins || {})) {
+            const summary = sanitizePluginInfo(plugin, trustFile);
+            const body = [
+                summary.description,
+                `status ${summary.status}`,
+                `trust ${summary.trust.state} ${summary.trust.riskLevel} ${summary.trust.signatureStatus}`,
+                `capabilities ${summary.capabilities.join(' ')}`,
+                `permissions ${summary.permissions.join(' ')}`,
+                `tools ${summary.tools.join(' ')}`,
+                `prompts ${summary.prompts.join(' ')}`,
+                `commands ${summary.commands.join(' ')}`,
+                summary.error ? `error ${summary.error}` : '',
+            ].filter(Boolean).join('\n');
+            documents.push({
+                id: stableDocumentId('plugin', key),
+                type: 'plugin',
+                scope: {},
+                acl: createScopeAcl({}, 'global'),
+                title: `Plugin ${summary.name}`,
+                body,
+                keywords: ['plugin', summary.name, summary.status, ...summary.capabilities, ...summary.tools],
+                sourcePath: summary.path,
+                timestamps: {
+                    createdAt: Date.parse(summary.installedAt) || undefined,
+                    updatedAt: Date.parse(summary.installedAt) || undefined,
+                },
+                metrics: { tokenEstimate: estimateTokens(body), bodyBytes: body.length },
+            });
+        }
+        for (const server of this.readMcpFile().servers) {
+            const body = [
+                `transport ${server.transport}`,
+                `scope ${server.scope}`,
+                server.command ? `command ${server.command} ${server.args.join(' ')}` : '',
+                server.url ? `url ${server.url}` : '',
+                `approval ${server.approvalState || 'pending'}`,
+                server.disabled ? 'disabled' : 'enabled',
+            ].filter(Boolean).join('\n');
+            documents.push({
+                id: stableDocumentId('mcp_server', server.name),
+                type: 'mcp_server',
+                scope: {},
+                acl: createScopeAcl({}, 'global'),
+                title: `MCP ${server.name}`,
+                body,
+                keywords: ['mcp', 'server', server.name, server.transport, server.scope, server.approvalState || 'pending'],
+                sourcePath: server.sourcePath,
+                timestamps: { createdAt: server.createdAt, updatedAt: server.updatedAt },
+                metrics: { tokenEstimate: estimateTokens(body), bodyBytes: body.length },
+            });
+        }
+        return documents;
+    }
+    resolveEffectivePolicy(caller, file = this.readMcpFile()) {
+        const normalizedCaller = normalizeCaller(caller);
+        const matched = file.scopedPolicies
+            .filter((policy) => policy.enabled !== false && scopeMatchesCaller(policy.scope, normalizedCaller))
+            .sort((left, right) => scopeSpecificity(left.scope) - scopeSpecificity(right.scope));
+        const effective = {
+            caller: normalizedCaller,
+            mcpRegistryPolicy: file.registryPolicy,
+            pluginAllowlist: [],
+            pluginDenylist: [],
+            mcpServerAllowlist: [],
+            mcpServerDenylist: [],
+            matchedPolicyIds: matched.map((policy) => policy.id),
+        };
+        for (const policy of matched) {
+            if (policy.mcpRegistryPolicy)
+                effective.mcpRegistryPolicy = policy.mcpRegistryPolicy;
+            effective.pluginAllowlist = normalizedList([...effective.pluginAllowlist, ...policy.pluginAllowlist]);
+            effective.pluginDenylist = normalizedList([...effective.pluginDenylist, ...policy.pluginDenylist]);
+            effective.mcpServerAllowlist = normalizedList([...effective.mcpServerAllowlist, ...policy.mcpServerAllowlist]);
+            effective.mcpServerDenylist = normalizedList([...effective.mcpServerDenylist, ...policy.mcpServerDenylist]);
+        }
+        return effective;
+    }
+    isPluginAllowed(name, policy) {
+        return isAllowedByPolicyLists(name, policy.pluginAllowlist, policy.pluginDenylist);
+    }
+    isMcpServerAllowed(name, policy) {
+        return isAllowedByPolicyLists(name, policy.mcpServerAllowlist, policy.mcpServerDenylist);
+    }
+    isMcpServerTrusted(name, file = this.readMcpFile()) {
+        const server = file.servers.find((entry) => entry.name === name);
+        return !!server && analyzeMcpTrust(server).state === 'trusted';
+    }
+    assertMcpServerUsable(serverName, caller, accessKind) {
+        const name = normalizeSearchText(serverName);
+        if (!name) {
+            throw new PluginMcpDeniedError(createDenial('mcp-name-required', 'MCP server name is required.', ['MCP server name is required.'], [remediation('configure-mcp', 'Choose MCP server', 'Select a configured MCP server before calling a tool, prompt, or resource.')]));
+        }
+        const file = this.readMcpFile();
+        const server = file.servers.find((entry) => entry.name === name);
+        if (!server) {
+            const reasons = [`MCP server "${name}" is not configured in Hub.`];
+            throw new PluginMcpDeniedError(createDenial('mcp-not-configured', reasons[0], reasons, trustRemediation('mcp', reasons)));
+        }
+        const effective = this.resolveEffectivePolicy(normalizeCaller(caller), file);
+        if (!this.isMcpServerAllowed(name, effective)) {
+            const reasons = [`MCP server "${name}" is denied by scoped policy.`];
+            throw new PluginMcpDeniedError(createDenial('mcp-scoped-policy-denied', reasons[0], reasons, trustRemediation('mcp', reasons)));
+        }
+        const trust = analyzeMcpTrust(server);
+        if (trust.state !== 'trusted') {
+            const reasons = trust.reasons;
+            throw new PluginMcpDeniedError(createDenial('mcp-not-trusted', `MCP server "${name}" is not trusted.`, reasons, trustRemediation('mcp', reasons)));
+        }
+        if (accessKind === 'prompt' && effective.mcpRegistryPolicy !== 'prompts' && effective.mcpRegistryPolicy !== 'context' && effective.mcpRegistryPolicy !== 'all') {
+            const reasons = [`MCP prompts are blocked by registry policy "${effective.mcpRegistryPolicy}".`];
+            throw new PluginMcpDeniedError(createDenial('mcp-registry-policy-denied', reasons[0], reasons, trustRemediation('mcp', reasons)));
+        }
+        if (accessKind === 'resource' && effective.mcpRegistryPolicy !== 'resources' && effective.mcpRegistryPolicy !== 'context' && effective.mcpRegistryPolicy !== 'all') {
+            const reasons = [`MCP resources are blocked by registry policy "${effective.mcpRegistryPolicy}".`];
+            throw new PluginMcpDeniedError(createDenial('mcp-registry-policy-denied', reasons[0], reasons, trustRemediation('mcp', reasons)));
+        }
+    }
+    recordMcpCallAudit(kind, serverName, target, preview) {
+        const auditId = stableDocumentId('mcp_call', kind, serverName, target, String(Date.now()), String(Math.random()));
+        this.appendMcpApproval({
+            id: auditId,
+            type: `call:${kind}`,
+            name: serverName,
+            target,
+            byteLength: preview.byteLength,
+            itemCount: preview.itemCount,
+            truncated: preview.truncated,
+            timestamp: new Date().toISOString(),
+        });
+        return auditId;
+    }
+    async getPluginHost() {
+        if (this.pluginHost)
+            return this.pluginHost;
+        const sdk = await loadSdk();
+        this.pluginHost = new sdk.PluginHost({
+            pluginDir: this.pluginDir,
+            autoActivate: false,
+            host: {
+                appName: 'xeno-hub',
+                appVersion: '0.2.3',
+                platform: process.platform,
+            },
+            defaultPermissions: ['tools:register', 'storage:read', 'storage:write'],
+            sandbox: {
+                enabled: true,
+                executionTimeout: 30_000,
+                blockedPaths: [join(homedir(), '.ssh'), join(homedir(), '.xeno', 'credentials.json')],
+            },
+        });
+        this.pluginHost.events.onAny((event) => this.recordPluginEvent(event));
+        await this.hydratePersistedActivePlugins(this.pluginHost);
+        return this.pluginHost;
+    }
+    async hydratePersistedActivePlugins(host) {
+        if (this.activePluginsHydrated)
+            return;
+        this.activePluginsHydrated = true;
+        const active = host.listInstalled().filter((plugin) => plugin.status === 'active');
+        const trustFile = this.readPluginTrustFile();
+        for (const plugin of active) {
+            try {
+                const trust = analyzePluginTrust(plugin, trustFile);
+                if (trust.state !== 'trusted') {
+                    await host.deactivate(plugin.manifest.name);
+                    this.recordPluginEvent({
+                        type: 'plugin:error',
+                        pluginName: plugin.manifest.name,
+                        timestamp: new Date().toISOString(),
+                        data: {
+                            phase: 'hydrate-active-plugin',
+                            reason: trust.reasons.join(' '),
+                        },
+                    });
+                    continue;
+                }
+                host.setStatus(plugin.manifest.name, 'installed');
+                await host.activate(plugin.manifest.name);
+            }
+            catch (err) {
+                this.recordPluginEvent({
+                    type: 'plugin:error',
+                    pluginName: plugin.manifest.name,
+                    timestamp: new Date().toISOString(),
+                    data: {
+                        phase: 'hydrate-active-plugin',
+                        error: err instanceof Error ? err.message : String(err),
+                    },
+                });
+            }
+        }
+    }
+    async getMcpManager() {
+        if (this.mcpManager)
+            return this.mcpManager;
+        const sdk = await loadSdk();
+        this.mcpManager = new sdk.MCPManager();
+        this.mcpUnsubscribe = this.mcpManager.onServerStateChanged((event) => {
+            this.appendMcpApproval({
+                name: event.serverName,
+                approvalKey: event.state.config.approvalKey || event.serverName,
+                decision: `state:${event.reason}`,
+                status: event.state.status,
+                error: event.state.error,
+                timestamp: new Date().toISOString(),
+            });
+        });
+        return this.mcpManager;
+    }
+    disposeMcpManager() {
+        try {
+            this.mcpUnsubscribe?.();
+        }
+        catch { /* noop */ }
+        this.mcpUnsubscribe = null;
+        try {
+            this.mcpManager?.dispose();
+        }
+        catch { /* noop */ }
+        this.mcpManager = null;
+    }
+    async withPlugin(inputName, handler) {
+        try {
+            const name = normalizeSearchText(inputName);
+            if (!name)
+                return { success: false, error: 'Plugin name is required.' };
+            const host = await this.getPluginHost();
+            if (!host.getPlugin(name))
+                return { success: false, error: `Plugin "${name}" is not installed.` };
+            return await handler(host, name);
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    normalizeHubMcpServer(input) {
+        const name = normalizeSearchText(input.name);
+        if (!name || !isMcpServerName(name))
+            throw new Error('Invalid MCP server name.');
+        const transport = input.transport || (input.url ? 'sse' : 'stdio');
+        if (transport !== 'stdio' && transport !== 'sse')
+            throw new Error('MCP transport must be stdio or sse.');
+        const command = optionalString(input.command);
+        const url = optionalString(input.url);
+        if (transport === 'stdio' && !command)
+            throw new Error('stdio MCP servers require a command.');
+        if (transport === 'sse' && !url)
+            throw new Error('sse MCP servers require a URL.');
+        const now = Date.now();
+        const scope = normalizeMcpScope(input.scope);
+        return {
+            name,
+            transport,
+            command,
+            args: stringArray(input.args),
+            env: stringRecord(input.env),
+            cwd: optionalString(input.cwd),
+            url,
+            headers: stringRecord(input.headers),
+            approvalRequired: input.approvalRequired ?? true,
+            disabled: !!input.disabled,
+            scope,
+            source: 'hub',
+            sourcePath: this.mcpServersPath,
+            approvalKey: input.approvalKey || `${scope}:${name}`,
+            createdAt: numberTimestamp(input.createdAt, now),
+            updatedAt: now,
+        };
+    }
+    readPluginTrustFile() {
+        const value = safeReadJson(this.pluginTrustPath, {});
+        const plugins = {};
+        for (const [name, entry] of Object.entries(value.plugins || {})) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const record = entry;
+            const decision = record.decision === 'approved' || record.decision === 'denied' ? record.decision : undefined;
+            if (!decision)
+                continue;
+            plugins[normalizePolicyKey(name)] = {
+                decision,
+                manifestHash: optionalString(record.manifestHash),
+                integrityHash: optionalString(record.integrityHash),
+                updatedAt: numberTimestamp(record.updatedAt),
+            };
+        }
+        return { version: 1, plugins };
+    }
+    writePluginTrustFile(file) {
+        safeWriteJson(this.pluginTrustPath, {
+            version: 1,
+            plugins: Object.fromEntries(Object.entries(file.plugins).sort(([left], [right]) => left.localeCompare(right))),
+        });
+    }
+    readMcpFile() {
+        const value = safeReadJson(this.mcpServersPath, {});
+        const servers = Array.isArray(value.servers)
+            ? value.servers
+                .filter((server) => !!server && typeof server === 'object' && typeof server.name === 'string')
+                .map((server) => ({
+                ...server,
+                source: server.source || 'hub',
+                sourcePath: server.sourcePath || this.mcpServersPath,
+                args: stringArray(server.args),
+                env: stringRecord(server.env),
+                headers: stringRecord(server.headers),
+                approvalRequired: server.approvalRequired ?? true,
+                approvalConfigHash: optionalString(server.approvalConfigHash),
+                disabled: !!server.disabled,
+                scope: normalizeMcpScope(server.scope),
+                createdAt: numberTimestamp(server.createdAt, Date.now()),
+                updatedAt: numberTimestamp(server.updatedAt, Date.now()),
+            }))
+            : [];
+        return {
+            version: 1,
+            registryPolicy: normalizeRegistryPolicy(value.registryPolicy),
+            scopedPolicies: Array.isArray(value.scopedPolicies)
+                ? value.scopedPolicies
+                    .filter((policy) => !!policy && typeof policy === 'object' && !!policy.scope)
+                    .map((policy) => normalizeScopedPolicy({
+                    ...policy,
+                    scope: normalizePolicyScope(policy.scope),
+                }, policy))
+                : [],
+            servers,
+        };
+    }
+    writeMcpFile(file) {
+        safeWriteJson(this.mcpServersPath, {
+            version: 1,
+            registryPolicy: normalizeRegistryPolicy(file.registryPolicy),
+            scopedPolicies: file.scopedPolicies
+                .map((policy) => normalizeScopedPolicy({ ...policy, scope: policy.scope }, policy))
+                .sort((left, right) => scopeSpecificity(left.scope) - scopeSpecificity(right.scope) || left.id.localeCompare(right.id)),
+            servers: file.servers.slice().sort((left, right) => left.name.localeCompare(right.name)),
+        });
+    }
+    async listConfiguredMcpRecords(request) {
+        const hubServers = this.readMcpFile().servers;
+        if (!request.includeSdkConfigured)
+            return hubServers;
+        try {
+            const manager = await this.getMcpManager();
+            const sdkConfigured = manager.loadConfiguredServers(request.cwd)
+                .map((server) => mcpRecordFromConfig(server, server.sourcePath, 'sdk-config'));
+            const hubNames = new Set(hubServers.map((server) => server.name));
+            return [
+                ...hubServers,
+                ...sdkConfigured.filter((server) => !hubNames.has(server.name)),
+            ];
+        }
+        catch {
+            return hubServers;
+        }
+    }
+    mergeMcpServerSummaries(configured, runtimeStates, manager) {
+        const runtimeByName = new Map(runtimeStates.map((state) => [state.config.name, state]));
+        const summaries = [];
+        for (const server of configured) {
+            const state = runtimeByName.get(server.name);
+            summaries.push(this.mcpServerSummary(server, state, manager));
+            runtimeByName.delete(server.name);
+        }
+        for (const state of runtimeByName.values()) {
+            summaries.push(this.mcpServerSummary(mcpRecordFromConfig(state.config, state.config.sourcePath || this.mcpServersPath, 'hub'), state, manager));
+        }
+        return summaries.sort((left, right) => left.name.localeCompare(right.name));
+    }
+    mcpServerSummary(record, state, manager) {
+        const tools = state ? manager.listTools(record.name).map(summarizeMcpTool) : [];
+        const prompts = state ? manager.listPrompts(record.name).map(summarizeMcpPrompt) : [];
+        const resources = state ? manager.listResources(record.name).map(summarizeMcpResource) : [];
+        return {
+            ...record,
+            status: state?.status || (record.disabled ? 'skipped' : 'configured'),
+            tools,
+            prompts,
+            resources,
+            trust: analyzeMcpTrust(record),
+            capabilities: state?.capabilities,
+            error: state?.error,
+        };
+    }
+    loadPluginEvents() {
+        try {
+            if (!existsSync(this.pluginEventLogPath))
+                return [];
+            return readFileSync(this.pluginEventLogPath, 'utf-8')
+                .split(/\r?\n/)
+                .filter(Boolean)
+                .slice(-MAX_PLUGIN_EVENTS)
+                .map((line) => JSON.parse(line));
+        }
+        catch {
+            return [];
+        }
+    }
+    recordPluginEvent(event) {
+        const record = {
+            id: stableDocumentId('plugin_event', event.pluginName, event.type, event.timestamp, String(this.pluginEvents.length)),
+            type: event.type,
+            pluginName: event.pluginName,
+            timestamp: event.timestamp,
+            data: event.data,
+        };
+        this.pluginEvents.push(record);
+        this.pluginEvents = this.pluginEvents.slice(-MAX_PLUGIN_EVENTS);
+        try {
+            ensureDir(dirname(this.pluginEventLogPath));
+            appendFileSync(this.pluginEventLogPath, `${JSON.stringify(record)}\n`, 'utf-8');
+        }
+        catch {
+            // Event logs are diagnostic; plugin lifecycle should continue if logging fails.
+        }
+    }
+    appendMcpApproval(record) {
+        try {
+            ensureDir(dirname(this.mcpApprovalsPath));
+            appendFileSync(this.mcpApprovalsPath, `${JSON.stringify(record)}\n`, 'utf-8');
+        }
+        catch {
+            // MCP audit logs are best-effort. Runtime calls surface their own errors.
+        }
+    }
+}
+let singleton = null;
+export function getPluginMcpManagerService() {
+    if (!singleton)
+        singleton = new PluginMcpManagerService();
+    return singleton;
+}
+//# sourceMappingURL=PluginMcpManagerService.js.map