@supen-ai/cli 0.1.6

package/daemon/dist/plugins/hub.js

@@ -0,0 +1,812 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import os from 'os';
+import path from 'path';
+import yaml from 'yaml';
+import { SUPEN_HOME, SKILLS_CONFIG, expandHomePath, resolveSpacePluginMountRoots, } from '../core/config.js';
+import { SkillHub } from '../skills/hub.js';
+import { loadOpenSupenSkillFromDirectory, resolveSkillSourceSpec } from '../skills/loader.js';
+import { logger } from '../core/logger.js';
+import { resolvePluginCatalogRoot } from './catalog.js';
+const PLUGINS_HOME = path.join(SUPEN_HOME, 'plugins');
+const PLUGINS_STATE_DIR = path.join(PLUGINS_HOME, '.state');
+const PLUGINS_STATE_PATH = path.join(PLUGINS_STATE_DIR, 'lock.json');
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isDirectory(targetPath) {
+    try {
+        return (await fs.stat(targetPath)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureDir(dirPath) {
+    await fs.mkdir(dirPath, { recursive: true });
+}
+function defaultState() {
+    return { version: 1, installed: {} };
+}
+function pluginHubError(message) {
+    throw new Error(message);
+}
+function normalizeSkillDeps(raw, pluginDir) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .map((entry) => {
+        if (typeof entry === 'string')
+            return { name: entry.trim() };
+        if (entry && typeof entry === 'object' && typeof entry.name === 'string') {
+            const rawSource = typeof entry.source === 'string'
+                ? String(entry.source).trim()
+                : '';
+            let source = rawSource;
+            if (source === '~' || source.startsWith('~/') || source.startsWith('@/')) {
+                source = expandHomePath(source);
+            }
+            else if (pluginDir && (source === '.' || source.startsWith('./') || source.startsWith('../'))) {
+                source = path.resolve(pluginDir, source);
+            }
+            return {
+                name: String(entry.name).trim(),
+                ...(source ? { source } : {}),
+            };
+        }
+        return null;
+    })
+        .filter((entry) => !!entry && entry.name.length > 0);
+}
+function normalizeMcpDeps(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .map((entry) => {
+        if (typeof entry === 'string')
+            return { id: entry.trim() };
+        if (entry && typeof entry === 'object' && typeof entry.id === 'string') {
+            return { id: String(entry.id).trim() };
+        }
+        return null;
+    })
+        .filter((entry) => !!entry && entry.id.length > 0);
+}
+function resolvePluginPath(pluginDir, relativePath) {
+    if (!relativePath || typeof relativePath !== 'string')
+        return null;
+    return path.resolve(pluginDir, relativePath);
+}
+function parseCommandFrontmatter(raw) {
+    if (!raw.startsWith('---\n'))
+        return {};
+    const end = raw.indexOf('\n---', 4);
+    if (end < 0)
+        return {};
+    try {
+        const parsed = yaml.parse(raw.slice(4, end));
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function normalizeCommandName(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+}
+function normalizePluginCommands(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .map((entry) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            return null;
+        const command = normalizeCommandName(entry.command);
+        const description = typeof entry.description === 'string' &&
+            entry.description.trim()
+            ? entry.description.trim()
+            : '';
+        if (!command || !description)
+            return null;
+        const argumentHint = typeof entry.argumentHint === 'string' &&
+            entry.argumentHint.trim()
+            ? entry.argumentHint.trim()
+            : undefined;
+        const handler = typeof entry.handler === 'string' &&
+            entry.handler.trim()
+            ? entry.handler.trim()
+            : undefined;
+        const visibility = entry.visibility === 'developer' ? 'developer' : undefined;
+        const channels = Array.isArray(entry.channels)
+            ? entry.channels
+                .filter((item) => typeof item === 'string' && item.trim().length > 0)
+                .map((item) => item.trim())
+            : undefined;
+        return {
+            command,
+            description,
+            ...(argumentHint ? { argumentHint } : {}),
+            ...(handler ? { handler } : {}),
+            ...(visibility ? { visibility } : {}),
+            ...(channels && channels.length > 0 ? { channels } : {}),
+        };
+    })
+        .filter((entry) => !!entry);
+}
+async function discoverSkillCommands(skillDir) {
+    const commandsDir = path.join(skillDir, 'commands');
+    if (!(await isDirectory(commandsDir)))
+        return [];
+    const commandPaths = (await fs.readdir(commandsDir, { withFileTypes: true }))
+        .filter((entry) => entry.isFile() && /\.(md|markdown)$/i.test(entry.name))
+        .map((entry) => path.join(commandsDir, entry.name))
+        .sort((left, right) => left.localeCompare(right));
+    const commands = [];
+    for (const commandPath of commandPaths) {
+        const frontmatter = parseCommandFrontmatter(await fs.readFile(commandPath, 'utf-8'));
+        const command = normalizeCommandName(frontmatter.command);
+        if (!command)
+            continue;
+        commands.push({
+            command,
+            description: typeof frontmatter.description === 'string' && frontmatter.description.trim()
+                ? frontmatter.description.trim()
+                : 'Run installed skill command',
+            ...(typeof frontmatter.argumentHint === 'string' && frontmatter.argumentHint.trim()
+                ? { argumentHint: frontmatter.argumentHint.trim() }
+                : {}),
+        });
+    }
+    return commands;
+}
+async function discoverSkillDeps(pluginDir, manifest) {
+    const canonicalSkillsDir = resolvePluginPath(pluginDir, manifest.skills);
+    if (!canonicalSkillsDir || !(await isDirectory(canonicalSkillsDir))) {
+        return normalizeSkillDeps(manifest.dependencies?.skills, pluginDir);
+    }
+    const skills = [];
+    for (const entry of await fs.readdir(canonicalSkillsDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const skillDir = path.join(canonicalSkillsDir, entry.name);
+        if (!(await pathExists(path.join(skillDir, 'SKILL.md'))))
+            continue;
+        try {
+            const discovered = loadOpenSupenSkillFromDirectory(skillDir);
+            const commands = await discoverSkillCommands(skillDir);
+            skills.push({
+                name: discovered.name,
+                source: skillDir,
+                ...(commands.length > 0 ? { commands } : {}),
+            });
+        }
+        catch (err) {
+            logger.warn({ err, skillDir }, 'Failed to read plugin skill');
+        }
+    }
+    return skills.sort((left, right) => left.name.localeCompare(right.name));
+}
+async function discoverMcpDeps(pluginDir, manifest) {
+    const canonicalMcpPath = resolvePluginPath(pluginDir, manifest.mcpServers);
+    if (!canonicalMcpPath || !(await pathExists(canonicalMcpPath))) {
+        return normalizeMcpDeps(manifest.dependencies?.mcpServers);
+    }
+    try {
+        const parsed = JSON.parse(await fs.readFile(canonicalMcpPath, 'utf-8'));
+        const rawServers = parsed && typeof parsed.mcpServers === 'object' && parsed.mcpServers !== null
+            ? parsed.mcpServers
+            : parsed;
+        if (!rawServers || typeof rawServers !== 'object')
+            return [];
+        return Object.entries(rawServers)
+            .map(([id, config]) => ({
+            id: id.trim(),
+            ...(config && typeof config === 'object' ? { config: config } : {}),
+        }))
+            .filter((entry) => entry.id.length > 0)
+            .sort((left, right) => left.id.localeCompare(right.id));
+    }
+    catch (err) {
+        logger.warn({ err, canonicalMcpPath }, 'Failed to read plugin MCP config');
+        return [];
+    }
+}
+function normalizeInterface(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    return raw;
+}
+function normalizeCapabilities(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .map((entry) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            return null;
+        const id = typeof entry.id === 'string' ? entry.id.trim() : '';
+        const displayName = typeof entry.displayName === 'string'
+            ? entry.displayName.trim()
+            : '';
+        if (!id || !displayName)
+            return null;
+        return entry;
+    })
+        .filter((entry) => !!entry);
+}
+function resolveLocalMcpServersRoot() {
+    const candidates = [
+        process.env.MCP_SERVERS_ROOT,
+        path.join(process.env.HOME || '', 'work', 'mcp-servers'),
+        path.join(process.env.HOME || '', 'tc', 'mcp-servers'),
+    ].filter((entry) => !!entry && entry.trim().length > 0);
+    for (const candidate of candidates) {
+        if (fsSync.existsSync(path.join(candidate, 'servers', 'office', 'index.mjs'))) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function expandPluginMcpString(value, pluginDir) {
+    const expanded = value.replace(/\$([A-Za-z_][A-Za-z0-9_]*)|\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (match, bare, braced) => {
+        const key = String(bare || braced || '');
+        if (key === 'MCP_SERVERS_ROOT') {
+            return process.env.MCP_SERVERS_ROOT || resolveLocalMcpServersRoot() || match;
+        }
+        return process.env[key] || match;
+    });
+    if (expanded === '~' || expanded.startsWith('~/')) {
+        return expandHomePath(expanded);
+    }
+    if (expanded === '.' || expanded.startsWith('./') || expanded.startsWith('../')) {
+        return path.resolve(pluginDir, expanded);
+    }
+    return expanded;
+}
+function runtimeConfigFromPluginMcp(dependency, pluginDir) {
+    const config = dependency.config || {};
+    const command = typeof config.command === 'string' ? config.command.trim() : '';
+    if (!command)
+        return null;
+    const args = Array.isArray(config.args)
+        ? config.args.filter((item) => typeof item === 'string').map((item) => expandPluginMcpString(item, pluginDir))
+        : [];
+    const rawEnv = config.env && typeof config.env === 'object' && !Array.isArray(config.env)
+        ? config.env
+        : {};
+    const env = Object.fromEntries(Object.entries(rawEnv)
+        .filter((entry) => typeof entry[1] === 'string')
+        .map(([key, value]) => [key, expandPluginMcpString(value, pluginDir)]));
+    return {
+        type: config.type === 'stdio' || config.type === undefined ? 'stdio' : undefined,
+        command: expandPluginMcpString(command, pluginDir),
+        ...(args.length > 0 ? { args } : {}),
+        ...(Object.keys(env).length > 0 ? { env } : {}),
+    };
+}
+function restoreInstalledPlugin(installed) {
+    const manifestPath = path.join(installed.directory, 'plugin.json');
+    return {
+        name: installed.name,
+        version: installed.version,
+        description: installed.description,
+        policy: installed.policy,
+        provider: installed.provider ?? 'supen',
+        directory: installed.directory,
+        manifestPath,
+        sourceRef: installed.sourceRef,
+        catalogSource: installed.catalogSource,
+        interface: installed.interface,
+        skills: installed.skills,
+        mcpServers: installed.mcpServers,
+        commands: installed.commands ?? [],
+    };
+}
+function resolveCodexPluginsRoot() {
+    const codexHome = process.env.CODEX_HOME && process.env.CODEX_HOME.trim().length > 0
+        ? expandHomePath(process.env.CODEX_HOME.trim())
+        : path.join(process.env.HOME || os.homedir(), '.codex');
+    return path.join(codexHome, 'plugins', 'cache');
+}
+function catalogSourceIdentity(source) {
+    if (!source)
+        return '';
+    return `${source.repo}#${source.branch}#${source.catalogPath}`;
+}
+function catalogSourceSyncedAt(plugin) {
+    const syncedAt = Date.parse(plugin.catalogSource?.syncedAt || '');
+    return Number.isFinite(syncedAt) ? syncedAt : 0;
+}
+function sourceRefIdentity(sourceRef) {
+    const raw = sourceRef?.canonical || sourceRef?.spec || '';
+    return raw ? path.resolve(raw) : '';
+}
+function candidateMatchesInstalledSource(plugin, installed) {
+    const pluginIdentity = sourceRefIdentity(plugin.sourceRef);
+    const installedIdentity = sourceRefIdentity(installed.sourceRef);
+    if (pluginIdentity && installedIdentity && pluginIdentity === installedIdentity) {
+        return true;
+    }
+    return path.resolve(plugin.directory) === path.resolve(installed.directory);
+}
+function selectDiscoveredPlugin(candidates, installed) {
+    const installedIdentity = catalogSourceIdentity(installed?.catalogSource);
+    const installedSourceCandidates = installed
+        ? candidates.filter((plugin) => candidateMatchesInstalledSource(plugin, installed))
+        : [];
+    const sameSourceCandidates = installedIdentity
+        ? candidates.filter((plugin) => (catalogSourceIdentity(plugin.catalogSource) === installedIdentity ||
+            installedSourceCandidates.includes(plugin)))
+        : [];
+    const pool = sameSourceCandidates.length > 0 ? sameSourceCandidates : candidates;
+    return [...pool].sort((left, right) => {
+        if (left.sourceRef.managed !== right.sourceRef.managed) {
+            return left.sourceRef.managed ? 1 : -1;
+        }
+        const timeDelta = catalogSourceSyncedAt(right) - catalogSourceSyncedAt(left);
+        if (timeDelta !== 0)
+            return timeDelta;
+        return (left.catalogSource?.id || '').localeCompare(right.catalogSource?.id || '');
+    })[0];
+}
+async function readCatalogSourceReference(sourceRoot) {
+    try {
+        const raw = JSON.parse(await fs.readFile(path.join(sourceRoot, '.supen-source.json'), 'utf-8'));
+        if (typeof raw?.id !== 'string' ||
+            typeof raw?.name !== 'string' ||
+            typeof raw?.repo !== 'string' ||
+            typeof raw?.branch !== 'string' ||
+            typeof raw?.catalogPath !== 'string') {
+            return undefined;
+        }
+        return {
+            id: raw.id,
+            name: raw.name,
+            repo: raw.repo,
+            branch: raw.branch,
+            catalogPath: raw.catalogPath,
+            ...(typeof raw.description === 'string' ? { description: raw.description } : {}),
+            ...(typeof raw.syncedAt === 'string' ? { syncedAt: raw.syncedAt } : {}),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export class PluginHub {
+    statePath;
+    constructor(statePath = PLUGINS_STATE_PATH) {
+        this.statePath = statePath;
+    }
+    async listAvailable() {
+        const state = await this.readState();
+        const discovered = await this.loadDiscoveredPlugins();
+        const discoveredByName = new Map();
+        for (const plugin of discovered) {
+            const candidates = discoveredByName.get(plugin.name) || [];
+            candidates.push(plugin);
+            discoveredByName.set(plugin.name, candidates);
+        }
+        const entries = [];
+        for (const [name, candidates] of discoveredByName.entries()) {
+            const installed = state.installed[name];
+            let pool = candidates;
+            if (installed &&
+                !candidates.some((candidate) => candidateMatchesInstalledSource(candidate, installed))) {
+                const installedSource = await this.loadPluginFromDirectory(installed.directory, {
+                    catalogSource: installed.catalogSource,
+                    managed: installed.sourceRef?.managed ?? false,
+                });
+                if (installedSource) {
+                    pool = [...pool, installedSource];
+                }
+            }
+            const plugin = selectDiscoveredPlugin(pool, installed);
+            entries.push({
+                plugin,
+                installed,
+                discovered: true,
+                installedExternally: plugin.provider === 'codex',
+            });
+        }
+        entries.sort((left, right) => left.plugin.name.localeCompare(right.plugin.name));
+        const seen = new Set(entries.map((entry) => entry.plugin.name));
+        for (const installed of Object.values(state.installed)) {
+            if (seen.has(installed.name))
+                continue;
+            const livePlugin = await this.loadPluginFromDirectory(installed.directory, {
+                catalogSource: installed.catalogSource,
+                managed: installed.sourceRef?.managed ?? false,
+            });
+            entries.push({
+                plugin: livePlugin || restoreInstalledPlugin(installed),
+                installed,
+                discovered: false,
+            });
+        }
+        return entries.sort((left, right) => left.plugin.name.localeCompare(right.plugin.name));
+    }
+    async inspectPlugin(name) {
+        return (await this.listAvailable()).find((entry) => entry.plugin.name === name);
+    }
+    async inspectPluginFromCatalogSources(name, catalogSourceIds) {
+        const preferredSourceIds = new Set(catalogSourceIds.filter(Boolean));
+        if (preferredSourceIds.size === 0)
+            return this.inspectPlugin(name);
+        const state = await this.readState();
+        const candidates = (await this.loadDiscoveredPlugins())
+            .filter((plugin) => (plugin.name === name &&
+            plugin.catalogSource?.id &&
+            preferredSourceIds.has(plugin.catalogSource.id)));
+        if (candidates.length === 0)
+            return undefined;
+        return {
+            plugin: selectDiscoveredPlugin(candidates, undefined),
+            installed: state.installed[name],
+            discovered: true,
+        };
+    }
+    async listInstalledCatalogSources() {
+        const state = await this.readState();
+        const seen = new Set();
+        const sources = [];
+        for (const record of Object.values(state.installed)) {
+            const source = record.catalogSource;
+            if (!source || seen.has(source.id))
+                continue;
+            seen.add(source.id);
+            sources.push(source);
+        }
+        return sources;
+    }
+    async installPlugin(name, context) {
+        const entry = await this.inspectPlugin(name);
+        if (!entry) {
+            pluginHubError(`Plugin "${name}" was not found.`);
+        }
+        const state = await this.readState();
+        const skillHub = new SkillHub(SKILLS_CONFIG);
+        const skillActions = [];
+        for (const dependency of entry.plugin.skills) {
+            const installed = skillHub.getInstalled(dependency.name);
+            if (!installed) {
+                const installTarget = skillHub.getSkill(dependency.name)
+                    ? dependency.name
+                    : dependency.source || dependency.name;
+                const installedRecord = skillHub.installSkill(installTarget, context, {
+                    trustSource: true,
+                    ...(dependency.source ? { upstreamSourceSpec: dependency.source } : {}),
+                });
+                if (installedRecord.name !== dependency.name) {
+                    pluginHubError(`Plugin dependency "${dependency.name}" resolved to skill "${installedRecord.name}".`);
+                }
+                const afterInstall = skillHub.getInstalled(dependency.name);
+                if (afterInstall && !afterInstall.enabled) {
+                    skillHub.enableSkill(dependency.name, context);
+                }
+                skillActions.push({ name: dependency.name, action: 'installed' });
+                continue;
+            }
+            if (!installed.enabled) {
+                skillHub.enableSkill(dependency.name, context);
+                skillActions.push({ name: dependency.name, action: 'enabled' });
+                continue;
+            }
+            skillActions.push({ name: dependency.name, action: 'already_enabled' });
+        }
+        const now = new Date().toISOString();
+        const next = {
+            name: entry.plugin.name,
+            version: entry.plugin.version,
+            description: entry.plugin.description,
+            policy: entry.plugin.policy,
+            directory: entry.plugin.directory,
+            sourceRef: entry.plugin.sourceRef,
+            catalogSource: entry.plugin.catalogSource,
+            interface: entry.plugin.interface,
+            capabilities: entry.plugin.capabilities,
+            commands: entry.plugin.commands,
+            skills: entry.plugin.skills,
+            mcpServers: entry.plugin.mcpServers,
+            installedAt: state.installed[entry.plugin.name]?.installedAt || now,
+            updatedAt: now,
+            installedBy: state.installed[entry.plugin.name]?.installedBy || context.actor,
+            lastActionBy: context.actor,
+        };
+        state.installed[entry.plugin.name] = next;
+        await this.writeState(state);
+        return {
+            plugin: next,
+            skillActions,
+            mcpServerIdsToEnable: next.mcpServers.map((item) => item.id),
+        };
+    }
+    async upgradePlugin(name, context, options = {}) {
+        const existing = (await this.readState()).installed[name];
+        if (!existing) {
+            pluginHubError(`Plugin "${name}" is not installed.`);
+        }
+        const entry = options.catalogSourceIds?.length
+            ? await this.inspectPluginFromCatalogSources(name, options.catalogSourceIds)
+            : await this.inspectPlugin(name);
+        if (!entry) {
+            pluginHubError(`Plugin "${name}" was not found.`);
+        }
+        const state = await this.readState();
+        const skillHub = new SkillHub(SKILLS_CONFIG);
+        const skillActions = [];
+        for (const dependency of entry.plugin.skills) {
+            const installed = skillHub.getInstalled(dependency.name);
+            if (!installed) {
+                const installTarget = skillHub.getSkill(dependency.name)
+                    ? dependency.name
+                    : dependency.source || dependency.name;
+                const installedRecord = skillHub.installSkill(installTarget, context, {
+                    trustSource: true,
+                    ...(dependency.source ? { upstreamSourceSpec: dependency.source } : {}),
+                });
+                if (installedRecord.name !== dependency.name) {
+                    pluginHubError(`Plugin dependency "${dependency.name}" resolved to skill "${installedRecord.name}".`);
+                }
+                const afterInstall = skillHub.getInstalled(dependency.name);
+                if (afterInstall && !afterInstall.enabled) {
+                    skillHub.enableSkill(dependency.name, context);
+                }
+                skillActions.push({ name: dependency.name, action: 'installed' });
+                continue;
+            }
+            skillHub.upgradeSkill(dependency.name, context, {
+                trustSource: true,
+                ...(dependency.source ? { upstreamSourceSpec: dependency.source } : {}),
+            });
+            const afterUpgrade = skillHub.getInstalled(dependency.name);
+            if (afterUpgrade && !afterUpgrade.enabled) {
+                skillHub.enableSkill(dependency.name, context);
+                skillActions.push({ name: dependency.name, action: 'enabled' });
+                continue;
+            }
+            skillActions.push({ name: dependency.name, action: 'upgraded' });
+        }
+        const now = new Date().toISOString();
+        const next = {
+            name: entry.plugin.name,
+            version: entry.plugin.version,
+            description: entry.plugin.description,
+            policy: entry.plugin.policy,
+            directory: entry.plugin.directory,
+            sourceRef: entry.plugin.sourceRef,
+            catalogSource: entry.plugin.catalogSource,
+            interface: entry.plugin.interface,
+            capabilities: entry.plugin.capabilities,
+            commands: entry.plugin.commands,
+            skills: entry.plugin.skills,
+            mcpServers: entry.plugin.mcpServers,
+            installedAt: existing.installedAt,
+            updatedAt: now,
+            installedBy: existing.installedBy,
+            lastActionBy: context.actor,
+        };
+        state.installed[entry.plugin.name] = next;
+        await this.writeState(state);
+        return {
+            plugin: next,
+            skillActions,
+            mcpServerIdsToEnable: next.mcpServers.map((item) => item.id),
+        };
+    }
+    async loadDiscoveredPlugins() {
+        const plugins = [];
+        const catalogRoot = resolvePluginCatalogRoot();
+        if (await isDirectory(catalogRoot)) {
+            for (const sourceDir of await fs.readdir(catalogRoot, { withFileTypes: true })) {
+                if (!sourceDir.isDirectory() || sourceDir.name.startsWith('.'))
+                    continue;
+                const sourceRoot = path.join(catalogRoot, sourceDir.name);
+                const catalogSource = await readCatalogSourceReference(sourceRoot);
+                plugins.push(...(await this.loadPluginsFromRoot(sourceRoot, {
+                    catalogSource,
+                    managed: true,
+                })));
+            }
+        }
+        for (const mountedRoot of resolveSpacePluginMountRoots()) {
+            plugins.push(...(await this.loadPluginsFromRoot(mountedRoot, { managed: false })));
+        }
+        plugins.push(...(await this.loadCodexPluginsFromRoot(resolveCodexPluginsRoot())));
+        return plugins;
+    }
+    async loadCodexPluginsFromRoot(sourceRoot) {
+        if (!(await isDirectory(sourceRoot)))
+            return [];
+        const manifestPaths = [];
+        const walk = async (dir, depth = 0) => {
+            if (depth > 8)
+                return;
+            let entries;
+            try {
+                entries = await fs.readdir(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const child = path.join(dir, entry.name);
+                if (entry.name === '.codex-plugin') {
+                    const manifestPath = path.join(child, 'plugin.json');
+                    if (await pathExists(manifestPath))
+                        manifestPaths.push(manifestPath);
+                    continue;
+                }
+                await walk(child, depth + 1);
+            }
+        };
+        await walk(sourceRoot);
+        const plugins = [];
+        for (const manifestPath of manifestPaths.sort((left, right) => left.localeCompare(right))) {
+            const plugin = await this.loadCodexPluginFromManifest(manifestPath);
+            if (plugin)
+                plugins.push(plugin);
+        }
+        return plugins;
+    }
+    async loadPluginsFromRoot(sourceRoot, options) {
+        if (!(await isDirectory(sourceRoot)))
+            return [];
+        const plugins = [];
+        for (const pluginDirEntry of await fs.readdir(sourceRoot, { withFileTypes: true })) {
+            if (!pluginDirEntry.isDirectory() || pluginDirEntry.name.startsWith('.'))
+                continue;
+            const directory = path.join(sourceRoot, pluginDirEntry.name);
+            const plugin = await this.loadPluginFromDirectory(directory, options);
+            if (plugin)
+                plugins.push(plugin);
+        }
+        return plugins;
+    }
+    async loadPluginFromDirectory(directory, options) {
+        const manifestPath = path.join(directory, 'plugin.json');
+        if (!(await pathExists(manifestPath)))
+            return undefined;
+        try {
+            const manifest = JSON.parse(await fs.readFile(manifestPath, 'utf-8'));
+            if (!manifest?.name || typeof manifest.name !== 'string')
+                return undefined;
+            const sourceRef = {
+                ...resolveSkillSourceSpec(directory),
+                managed: options.managed,
+                trusted: true,
+            };
+            return {
+                name: manifest.name.trim(),
+                version: typeof manifest.version === 'string' && manifest.version.trim() ? manifest.version.trim() : '0.0.0',
+                description: typeof manifest.description === 'string' && manifest.description.trim()
+                    ? manifest.description.trim()
+                    : 'No description',
+                policy: 'bundle_safe_sync',
+                provider: 'supen',
+                directory,
+                manifestPath,
+                sourceRef,
+                catalogSource: options.catalogSource,
+                interface: normalizeInterface(manifest.interface),
+                capabilities: normalizeCapabilities(manifest.capabilities),
+                commands: normalizePluginCommands(manifest.commands),
+                skills: await discoverSkillDeps(directory, manifest),
+                mcpServers: await discoverMcpDeps(directory, manifest),
+            };
+        }
+        catch (err) {
+            logger.warn({ err, manifestPath }, 'Failed to read plugin manifest');
+            return undefined;
+        }
+    }
+    async loadCodexPluginFromManifest(manifestPath) {
+        const directory = path.dirname(path.dirname(manifestPath));
+        try {
+            const manifest = JSON.parse(await fs.readFile(manifestPath, 'utf-8'));
+            if (!manifest?.name || typeof manifest.name !== 'string')
+                return undefined;
+            const sourceRef = {
+                ...resolveSkillSourceSpec(directory),
+                managed: true,
+                trusted: true,
+            };
+            return {
+                name: manifest.name.trim(),
+                version: typeof manifest.version === 'string' && manifest.version.trim() ? manifest.version.trim() : '0.0.0',
+                description: typeof manifest.description === 'string' && manifest.description.trim()
+                    ? manifest.description.trim()
+                    : 'No description',
+                policy: 'bundle_safe_sync',
+                provider: 'codex',
+                directory,
+                manifestPath,
+                sourceRef,
+                interface: normalizeInterface(manifest.interface),
+                capabilities: normalizeCapabilities(manifest.capabilities),
+                commands: normalizePluginCommands(manifest.commands),
+                skills: await discoverSkillDeps(directory, manifest),
+                mcpServers: await discoverMcpDeps(directory, manifest),
+            };
+        }
+        catch (err) {
+            logger.warn({ err, manifestPath }, 'Failed to read Codex plugin manifest');
+            return undefined;
+        }
+    }
+    async readState() {
+        try {
+            const parsed = JSON.parse(await fs.readFile(this.statePath, 'utf-8'));
+            const installed = {};
+            for (const [name, value] of Object.entries(parsed.installed || {})) {
+                const record = value;
+                if (!record || typeof record.name !== 'string')
+                    continue;
+                installed[name] = {
+                    name: record.name,
+                    version: record.version || '0.0.0',
+                    description: record.description || 'No description',
+                    policy: 'bundle_safe_sync',
+                    provider: record.provider ?? 'supen',
+                    directory: record.directory || '',
+                    sourceRef: record.sourceRef,
+                    catalogSource: record.catalogSource,
+                    interface: record.interface,
+                    capabilities: Array.isArray(record.capabilities) ? record.capabilities : [],
+                    commands: Array.isArray(record.commands) ? record.commands : [],
+                    skills: Array.isArray(record.skills) ? record.skills : [],
+                    mcpServers: Array.isArray(record.mcpServers) ? record.mcpServers : [],
+                    installedAt: record.installedAt || new Date(0).toISOString(),
+                    updatedAt: record.updatedAt || record.installedAt || new Date(0).toISOString(),
+                    installedBy: record.installedBy || 'unknown',
+                    lastActionBy: record.lastActionBy || record.installedBy || 'unknown',
+                };
+            }
+            return { version: 1, installed };
+        }
+        catch {
+            return defaultState();
+        }
+    }
+    async writeState(state) {
+        await ensureDir(path.dirname(this.statePath));
+        await fs.writeFile(this.statePath, `${JSON.stringify(state, null, 2)}\n`, 'utf-8');
+    }
+}
+export async function resolveInstalledPluginMcpServers(statePath = PLUGINS_STATE_PATH) {
+    try {
+        if (!(await pathExists(statePath))) {
+            return {};
+        }
+        const parsed = JSON.parse(await fs.readFile(statePath, 'utf-8'));
+        const servers = {};
+        for (const record of Object.values(parsed.installed || {})) {
+            const installed = record;
+            if (!installed || !Array.isArray(installed.mcpServers))
+                continue;
+            for (const dependency of installed.mcpServers) {
+                const config = runtimeConfigFromPluginMcp(dependency, installed.directory || '');
+                if (config)
+                    servers[dependency.id] = config;
+            }
+        }
+        return servers;
+    }
+    catch (err) {
+        logger.warn({ err, statePath }, 'Failed to read installed plugin MCP servers');
+        return {};
+    }
+}
+//# sourceMappingURL=hub.js.map