@hydraharness/harness-host-plugin-inventory 0.1.1-rc.10

package/lib/types/index.js

@@ -0,0 +1,1230 @@
+/** Runtime plugin inventory plus shared user-setting enablement controls. */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { execFile } from 'node:child_process';
+import { lstat, mkdtemp, readFile, realpath, rm, stat } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Service } from '@hydraharness/cordis';
+import { profilePluginEnablement, readProfileManifest, resolveProfileDir } from '@hydraharness/harness-app-boot';
+import { withFileLock, writeFileAtomic } from '@hydraharness/harness-atomic-write';
+import { settingsNamespace } from '@hydraharness/harness-settings';
+import { TypertRemoteService, Remote } from '@hydraharness/harness-typert-protocol';
+import z from '@hydraharness/schemastery';
+import { z as zod } from 'zod';
+/** Brand an existing Loader-tree entry id at the owning boundary. */
+function pluginEntryId(value) {
+    return value;
+}
+/** Runtime mirror: FiberState is a cross-package const enum. */
+const FIBER_STATE = {
+    PENDING: 0,
+    LOADING: 1,
+    ACTIVE: 2,
+    FAILED: 3,
+    DISPOSED: 4,
+    UNLOADING: 5,
+};
+/** Complete public projection of Cordis Fiber states. */
+const FIBER_PHASE = {
+    [FIBER_STATE.PENDING]: 'pending',
+    [FIBER_STATE.LOADING]: 'loading',
+    [FIBER_STATE.ACTIVE]: 'active',
+    [FIBER_STATE.FAILED]: 'failed',
+    [FIBER_STATE.DISPOSED]: null,
+    [FIBER_STATE.UNLOADING]: 'unloading',
+};
+const PLUGIN_SETTINGS_NAMESPACE = settingsNamespace('plugins');
+const MARKETPLACE_SETTINGS_NAMESPACE = settingsNamespace('plugin-marketplaces');
+const HMR_MODULE = '@hydraharness/cordis-plugin-hmr';
+const AGENT_PRESET_ENTRY_PREFIX = 'agent-preset:';
+const MAX_MARKETPLACE_BYTES = 1024 * 1024;
+const MARKETPLACE_GIT_TIMEOUT_MS = 30_000;
+const MAX_MARKETPLACE_SPARSE_PATHS = 20;
+const MAX_MARKETPLACE_SPARSE_PATH_LENGTH = 512;
+const GITHUB_SHORTHAND_PATTERN = /^([A-Za-z0-9][A-Za-z0-9._-]*)\/([A-Za-z0-9][A-Za-z0-9._-]*)$/u;
+const MarketplaceDocumentSchema = zod.object({
+    plugins: zod.array(zod.record(zod.string(), zod.unknown())).max(500),
+}).loose();
+const PluginMetadataSchema = zod.object({
+    description: zod.string().trim().min(1).optional(),
+    application: zod.string().trim().min(1).optional(),
+});
+const PluginPackageSchema = zod.object({
+    description: PluginMetadataSchema.shape.description,
+    hydra: zod.object({
+        plugin: zod.object({ application: zod.string().trim().min(1).optional() }).optional(),
+    }).optional(),
+});
+/** Read presentation metadata without importing or activating the plugin. */
+async function pluginMetadata(moduleName, baseUrl, options = {}) {
+    const overrides = PluginMetadataSchema.parse(options);
+    const metadata = {
+        ...overrides.description === undefined ? {} : { description: overrides.description },
+        ...overrides.application === undefined ? {} : { application: overrides.application },
+    };
+    if (baseUrl === undefined || moduleName.startsWith('.') || moduleName.startsWith('/')
+        || moduleName.includes(':') || moduleName.includes('\\'))
+        return metadata;
+    const packageName = moduleName.split('/').slice(0, moduleName.startsWith('@') ? 2 : 1).join('/');
+    let path;
+    try {
+        path = createRequire(baseUrl).resolve(`${packageName}/package.json`);
+    }
+    catch (error) {
+        // Disabled packages may be absent; third-party packages may hide their manifest.
+        if (error instanceof Error && 'code' in error
+            && (error.code === 'MODULE_NOT_FOUND' || error.code === 'ERR_PACKAGE_PATH_NOT_EXPORTED'))
+            return metadata;
+        throw error;
+    }
+    const result = PluginPackageSchema.safeParse(JSON.parse(await readFile(path, 'utf8')));
+    if (!result.success)
+        throw new Error(`pluginInventory: invalid plugin metadata in ${path}`, { cause: result.error });
+    const { description, hydra } = result.data;
+    return {
+        ...description === undefined ? {} : { description },
+        ...hydra?.plugin?.application === undefined ? {} : { application: hydra.plugin.application },
+        ...metadata,
+    };
+}
+const PluginSettingsSchema = z.object({
+    enabled: z.dict(z.boolean()).default({}),
+});
+const MarketplaceSourceSchema = z.object({
+    source: z.string(),
+    gitRef: z.string().default(''),
+    sparsePaths: z.array(z.string()).max(MAX_MARKETPLACE_SPARSE_PATHS).default([]),
+    enabled: z.boolean().default(true),
+});
+const MarketplaceSettingsSchema = z.object({
+    sources: z.array(MarketplaceSourceSchema).max(20).default([]),
+});
+function missingPath(error) {
+    return error instanceof Error
+        && 'code' in error
+        && (error.code === 'ENOENT' || error.code === 'ENOTDIR');
+}
+function normalizeGitRef(value) {
+    const gitRef = value?.trim();
+    if (gitRef === undefined || gitRef === '')
+        return undefined;
+    if (gitRef.length > 255
+        || gitRef.startsWith('-')
+        || /[\u0000-\u0020\u007F]/u.test(gitRef)) {
+        throw new Error('pluginInventory: Git ref is invalid');
+    }
+    return gitRef;
+}
+function normalizeSparsePaths(values) {
+    if ((values?.length ?? 0) > MAX_MARKETPLACE_SPARSE_PATHS) {
+        throw new Error(`pluginInventory: at most ${String(MAX_MARKETPLACE_SPARSE_PATHS)} sparse paths are allowed`);
+    }
+    const paths = (values ?? []).map((value) => {
+        const path = value.trim().replaceAll('\\', '/').replace(/\/+$/u, '');
+        if (path.length > MAX_MARKETPLACE_SPARSE_PATH_LENGTH) {
+            throw new Error(`pluginInventory: sparse paths may contain at most ${String(MAX_MARKETPLACE_SPARSE_PATH_LENGTH)} characters`);
+        }
+        const segments = path.split('/');
+        if (path === ''
+            || path.startsWith('/')
+            || path.startsWith('-')
+            || /^[A-Za-z]:\//u.test(path)
+            || segments.some(segment => segment === '' || segment === '.' || segment === '..')) {
+            throw new Error(`pluginInventory: sparse path ${JSON.stringify(value)} must be repository-relative`);
+        }
+        return path;
+    });
+    return [...new Set(paths)].sort();
+}
+function normalizeGitSource(source) {
+    const shorthand = GITHUB_SHORTHAND_PATTERN.exec(source);
+    if (shorthand !== null) {
+        /* v8 ignore next -- A successful shorthand match contains both required captures. */
+        const owner = shorthand[1] ?? '';
+        /* v8 ignore next -- A successful shorthand match contains both required captures. */
+        const repository = (shorthand[2] ?? '').replace(/\.git$/u, '');
+        return `https://github.com/${owner}/${repository}.git`;
+    }
+    if (/^[A-Za-z0-9._-]+@[A-Za-z0-9.-]+:[A-Za-z0-9._~/-]+$/u.test(source))
+        return source;
+    let url;
+    try {
+        url = new URL(source);
+    }
+    catch (cause) {
+        throw new Error('pluginInventory: source must be a GitHub repo, Git URL, or existing local folder', { cause });
+    }
+    if (url.protocol !== 'https:' && url.protocol !== 'ssh:') {
+        throw new Error('pluginInventory: remote marketplace source must use HTTPS or SSH');
+    }
+    if (url.password !== '' || url.hash !== '' || url.search !== ''
+        || (url.protocol === 'https:' && url.username !== '')) {
+        throw new Error('pluginInventory: marketplace source cannot contain credentials, a query, or a fragment');
+    }
+    return url.href;
+}
+async function normalizeMarketplaceSource(request) {
+    const source = request.source.trim();
+    if (source === '' || source.length > 2048 || /[\u0000-\u001F\u007F]/u.test(source)) {
+        throw new Error('pluginInventory: marketplace source is invalid');
+    }
+    const gitRef = normalizeGitRef(request.gitRef);
+    const sparsePaths = normalizeSparsePaths(request.sparsePaths);
+    const localPath = resolve(source);
+    try {
+        if (!GITHUB_SHORTHAND_PATTERN.test(source) && (await stat(localPath)).isDirectory()) {
+            if (gitRef !== undefined || sparsePaths.length > 0) {
+                throw new Error('pluginInventory: Git ref and sparse paths require a Git source');
+            }
+            return { kind: 'local', source: await realpath(localPath), gitRef: '', sparsePaths: [], enabled: true };
+        }
+    }
+    catch (error) {
+        if (!missingPath(error))
+            throw error;
+    }
+    return {
+        kind: 'git',
+        source: normalizeGitSource(source),
+        gitRef: gitRef ?? '',
+        sparsePaths,
+        enabled: true,
+    };
+}
+function marketplaceGitEnv() {
+    const env = {};
+    for (const [name, value] of Object.entries(process.env)) {
+        if (!/(?:KEY|SECRET|TOKEN|PASSWORD)/iu.test(name))
+            env[name] = value;
+    }
+    env.GCM_INTERACTIVE = 'Never';
+    env.GIT_TERMINAL_PROMPT = '0';
+    return env;
+}
+function runGit(cwd, args) {
+    return new Promise((resolvePromise, reject) => {
+        execFile('git', [
+            '-c', 'protocol.ext.allow=never',
+            '-c', 'protocol.file.allow=never',
+            ...args,
+        ], {
+            cwd,
+            encoding: 'utf8',
+            env: marketplaceGitEnv(),
+            maxBuffer: MAX_MARKETPLACE_BYTES,
+            timeout: MARKETPLACE_GIT_TIMEOUT_MS,
+            windowsHide: true,
+        }, (error, _stdout, stderr) => {
+            if (error === null) {
+                resolvePromise();
+                return;
+            }
+            const detail = stderr.trim().split(/\r?\n/u)[0];
+            reject(new Error(`pluginInventory: failed to load Git marketplace${detail === undefined || detail === '' ? '' : `: ${detail}`}`, { cause: error }));
+        });
+    });
+}
+async function readMarketplaceDocument(root) {
+    for (const relativePath of ['.agents/plugins/marketplace.json', '.agents/plugins/api_marketplace.json', 'marketplace.json']) {
+        const filename = join(root, relativePath);
+        try {
+            const metadata = await lstat(filename);
+            if (!metadata.isFile())
+                continue;
+            if (metadata.size > MAX_MARKETPLACE_BYTES) {
+                throw new Error(`pluginInventory: marketplace exceeds ${String(MAX_MARKETPLACE_BYTES)} bytes`);
+            }
+            const body = await readFile(filename);
+            if (body.byteLength > MAX_MARKETPLACE_BYTES) {
+                throw new Error(`pluginInventory: marketplace exceeds ${String(MAX_MARKETPLACE_BYTES)} bytes`);
+            }
+            return MarketplaceDocumentSchema.parse(JSON.parse(body.toString('utf8')));
+        }
+        catch (error) {
+            if (missingPath(error))
+                continue;
+            throw error;
+        }
+    }
+    throw new Error('pluginInventory: OpenAI/Codex marketplace.json is missing');
+}
+/** Load and validate one marketplace root without retaining an executable checkout. */
+async function loadMarketplace(request) {
+    const normalized = await normalizeMarketplaceSource(request);
+    const { kind, ...source } = normalized;
+    if (kind === 'local') {
+        return { source, document: await readMarketplaceDocument(source.source) };
+    }
+    // Temporary shallow clones avoid cache invalidation; add snapshots if list latency becomes material.
+    const tempRoot = await mkdtemp(join(tmpdir(), 'hydra-marketplace-'));
+    const checkout = join(tempRoot, 'repository');
+    try {
+        if (source.gitRef !== '') {
+            try {
+                await runGit(tempRoot, ['check-ref-format', '--allow-onelevel', source.gitRef]);
+            }
+            catch (cause) {
+                throw new Error('pluginInventory: Git ref is invalid', { cause });
+            }
+        }
+        const cloneArgs = ['clone', '--depth', '1', '--filter=blob:none'];
+        if (source.sparsePaths.length > 0)
+            cloneArgs.push('--sparse');
+        if (source.gitRef !== '')
+            cloneArgs.push('--no-checkout');
+        cloneArgs.push('--', source.source, checkout);
+        await runGit(tempRoot, cloneArgs);
+        if (source.gitRef !== '') {
+            await runGit(tempRoot, ['-C', checkout, 'fetch', '--depth', '1', 'origin', source.gitRef]);
+        }
+        if (source.sparsePaths.length > 0) {
+            await runGit(tempRoot, [
+                '-C', checkout, 'sparse-checkout', 'set', '--cone', '--sparse-index', '--',
+                '.agents/plugins', ...source.sparsePaths,
+            ]);
+        }
+        if (source.gitRef !== '') {
+            await runGit(tempRoot, ['-C', checkout, 'checkout', '--detach', 'FETCH_HEAD']);
+        }
+        return { source, document: await readMarketplaceDocument(checkout) };
+    }
+    finally {
+        await rm(tempRoot, { recursive: true, force: true });
+    }
+}
+/** Remote-only service exposing the Loader's current non-group entry state. */
+let PluginInventoryGateway = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _list_decorators;
+    let _setEnabled_decorators;
+    let _listMarketplaces_decorators;
+    let _addMarketplace_decorators;
+    let _setMarketplaceEnabled_decorators;
+    let _removeMarketplace_decorators;
+    let _listImportedPlugins_decorators;
+    let _importPlugin_decorators;
+    let _infoPlugin_decorators;
+    let _enablePlugin_decorators;
+    let _disablePlugin_decorators;
+    let _setPluginMcpServerEnabled_decorators;
+    let _setPluginMcpToolApproval_decorators;
+    let _trustPlugin_decorators;
+    let _untrustPlugin_decorators;
+    let _removePlugin_decorators;
+    let _listMcpServers_decorators;
+    let _defineMcpServer_decorators;
+    let _setMcpServerEnabled_decorators;
+    let _removeMcpServer_decorators;
+    let _listHookRecords_decorators;
+    let _defineHookRecord_decorators;
+    let _setHookRecordEnabled_decorators;
+    let _removeHookRecord_decorators;
+    return class PluginInventoryGateway extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _list_decorators = [Remote('list')];
+            _setEnabled_decorators = [Remote('setEnabled')];
+            _listMarketplaces_decorators = [Remote('listMarketplaces')];
+            _addMarketplace_decorators = [Remote('addMarketplace')];
+            _setMarketplaceEnabled_decorators = [Remote('setMarketplaceEnabled')];
+            _removeMarketplace_decorators = [Remote('removeMarketplace')];
+            _listImportedPlugins_decorators = [Remote('listImportedPlugins')];
+            _importPlugin_decorators = [Remote('importPlugin')];
+            _infoPlugin_decorators = [Remote('infoPlugin')];
+            _enablePlugin_decorators = [Remote('enablePlugin')];
+            _disablePlugin_decorators = [Remote('disablePlugin')];
+            _setPluginMcpServerEnabled_decorators = [Remote('setPluginMcpServerEnabled')];
+            _setPluginMcpToolApproval_decorators = [Remote('setPluginMcpToolApproval')];
+            _trustPlugin_decorators = [Remote('trustPlugin')];
+            _untrustPlugin_decorators = [Remote('untrustPlugin')];
+            _removePlugin_decorators = [Remote('removePlugin')];
+            _listMcpServers_decorators = [Remote('listMcpServers')];
+            _defineMcpServer_decorators = [Remote('defineMcpServer')];
+            _setMcpServerEnabled_decorators = [Remote('setMcpServerEnabled')];
+            _removeMcpServer_decorators = [Remote('removeMcpServer')];
+            _listHookRecords_decorators = [Remote('listHookRecords')];
+            _defineHookRecord_decorators = [Remote('defineHookRecord')];
+            _setHookRecordEnabled_decorators = [Remote('setHookRecordEnabled')];
+            _removeHookRecord_decorators = [Remote('removeHookRecord')];
+            __esDecorate(this, null, _list_decorators, { kind: "method", name: "list", static: false, private: false, access: { has: obj => "list" in obj, get: obj => obj.list }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setEnabled_decorators, { kind: "method", name: "setEnabled", static: false, private: false, access: { has: obj => "setEnabled" in obj, get: obj => obj.setEnabled }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _listMarketplaces_decorators, { kind: "method", name: "listMarketplaces", static: false, private: false, access: { has: obj => "listMarketplaces" in obj, get: obj => obj.listMarketplaces }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _addMarketplace_decorators, { kind: "method", name: "addMarketplace", static: false, private: false, access: { has: obj => "addMarketplace" in obj, get: obj => obj.addMarketplace }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setMarketplaceEnabled_decorators, { kind: "method", name: "setMarketplaceEnabled", static: false, private: false, access: { has: obj => "setMarketplaceEnabled" in obj, get: obj => obj.setMarketplaceEnabled }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _removeMarketplace_decorators, { kind: "method", name: "removeMarketplace", static: false, private: false, access: { has: obj => "removeMarketplace" in obj, get: obj => obj.removeMarketplace }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _listImportedPlugins_decorators, { kind: "method", name: "listImportedPlugins", static: false, private: false, access: { has: obj => "listImportedPlugins" in obj, get: obj => obj.listImportedPlugins }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _importPlugin_decorators, { kind: "method", name: "importPlugin", static: false, private: false, access: { has: obj => "importPlugin" in obj, get: obj => obj.importPlugin }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _infoPlugin_decorators, { kind: "method", name: "infoPlugin", static: false, private: false, access: { has: obj => "infoPlugin" in obj, get: obj => obj.infoPlugin }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _enablePlugin_decorators, { kind: "method", name: "enablePlugin", static: false, private: false, access: { has: obj => "enablePlugin" in obj, get: obj => obj.enablePlugin }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _disablePlugin_decorators, { kind: "method", name: "disablePlugin", static: false, private: false, access: { has: obj => "disablePlugin" in obj, get: obj => obj.disablePlugin }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setPluginMcpServerEnabled_decorators, { kind: "method", name: "setPluginMcpServerEnabled", static: false, private: false, access: { has: obj => "setPluginMcpServerEnabled" in obj, get: obj => obj.setPluginMcpServerEnabled }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setPluginMcpToolApproval_decorators, { kind: "method", name: "setPluginMcpToolApproval", static: false, private: false, access: { has: obj => "setPluginMcpToolApproval" in obj, get: obj => obj.setPluginMcpToolApproval }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _trustPlugin_decorators, { kind: "method", name: "trustPlugin", static: false, private: false, access: { has: obj => "trustPlugin" in obj, get: obj => obj.trustPlugin }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _untrustPlugin_decorators, { kind: "method", name: "untrustPlugin", static: false, private: false, access: { has: obj => "untrustPlugin" in obj, get: obj => obj.untrustPlugin }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _removePlugin_decorators, { kind: "method", name: "removePlugin", static: false, private: false, access: { has: obj => "removePlugin" in obj, get: obj => obj.removePlugin }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _listMcpServers_decorators, { kind: "method", name: "listMcpServers", static: false, private: false, access: { has: obj => "listMcpServers" in obj, get: obj => obj.listMcpServers }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _defineMcpServer_decorators, { kind: "method", name: "defineMcpServer", static: false, private: false, access: { has: obj => "defineMcpServer" in obj, get: obj => obj.defineMcpServer }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setMcpServerEnabled_decorators, { kind: "method", name: "setMcpServerEnabled", static: false, private: false, access: { has: obj => "setMcpServerEnabled" in obj, get: obj => obj.setMcpServerEnabled }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _removeMcpServer_decorators, { kind: "method", name: "removeMcpServer", static: false, private: false, access: { has: obj => "removeMcpServer" in obj, get: obj => obj.removeMcpServer }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _listHookRecords_decorators, { kind: "method", name: "listHookRecords", static: false, private: false, access: { has: obj => "listHookRecords" in obj, get: obj => obj.listHookRecords }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _defineHookRecord_decorators, { kind: "method", name: "defineHookRecord", static: false, private: false, access: { has: obj => "defineHookRecord" in obj, get: obj => obj.defineHookRecord }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setHookRecordEnabled_decorators, { kind: "method", name: "setHookRecordEnabled", static: false, private: false, access: { has: obj => "setHookRecordEnabled" in obj, get: obj => obj.setHookRecordEnabled }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _removeHookRecord_decorators, { kind: "method", name: "removeHookRecord", static: false, private: false, access: { has: obj => "removeHookRecord" in obj, get: obj => obj.removeHookRecord }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static inject = ['loader', 'settings'];
+        static Config = z.object({
+            compositionEntryIds: z.array(z.string()).default([]),
+        });
+        compositionEntryIds = __runInitializers(this, _instanceExtraInitializers);
+        settings;
+        marketplaceSettings;
+        defaultEnabled = new Map();
+        initialEnabled = new Map();
+        originalConfigs = new Map();
+        suspended = new Map();
+        required = new Set();
+        appliedSettings = new Set();
+        restartEnablement = {};
+        mutationTail = Promise.resolve();
+        constructor(ctx, config = {}) {
+            super(ctx, 'pluginInventory');
+            this.compositionEntryIds = new Set(config.compositionEntryIds);
+            this.settings = ctx.settings.register(PLUGIN_SETTINGS_NAMESPACE, PluginSettingsSchema);
+            this.marketplaceSettings = ctx.settings.register(MARKETPLACE_SETTINGS_NAMESPACE, MarketplaceSettingsSchema);
+            ctx.inject(['optionalPlugins'], (pctx) => {
+                pctx.effect(() => pctx.optionalPlugins.subscribe((enabled) => {
+                    void this.enqueue(() => this.applyOptionalGate(enabled)).catch((error) => { this.ctx.logger.error(error); });
+                }), 'pluginInventory: optional policy');
+                void this.enqueue(() => this.applyOptionalGate(pctx.optionalPlugins.enabled))
+                    .catch((error) => { this.ctx.logger.error(error); });
+            });
+            ctx.on('loader/config-update', () => {
+                const policy = ctx.get('optionalPlugins');
+                if (policy !== undefined)
+                    void this.enqueue(() => this.applyOptionalGate(policy.enabled))
+                        .catch((error) => { ctx.logger.error(error); });
+            });
+        }
+        async [Service.init]() {
+            const rootInclude = this.rootInclude();
+            if (rootInclude === undefined)
+                return;
+            const representatives = this.representatives(rootInclude);
+            for (const entry of representatives.values()) {
+                this.defaultEnabled.set(entry.options.name, !entry.disabled && !this.isHmrWatchOnly(entry));
+                this.originalConfigs.set(entry.options.name, structuredClone(entry.options.config));
+            }
+            if ([...representatives.values()].some(entry => this.isRestartOnly(entry))) {
+                this.restartEnablement = profilePluginEnablement(readProfileManifest('pluginInventory', this.profileDir()));
+            }
+            await this.applySettings(this.settings.get().enabled);
+            for (const entry of representatives.values())
+                this.initialEnabled.set(entry.id, this.enabled(entry));
+            this.ctx.effect(() => this.settings.watch(next => this.enqueue(() => this.applySettings(next.enabled))), 'pluginInventory.settingsWatch');
+        }
+        /** Protect required modules and their declared dependency closure before suspending root-owned features. */
+        async applyOptionalGate(enabled) {
+            const policy = this.ctx.get('optionalPlugins');
+            if (policy === undefined)
+                return;
+            if (!enabled)
+                await policy.drain();
+            if (policy.enabled !== enabled)
+                return;
+            const entries = [...this.representatives(this.rootInclude()).values()];
+            const byModule = new Map(entries.map(entry => [entry.options.name, entry]));
+            const pending = entries.filter(entry => entry.options.pluginRequired === true).map(entry => entry.options.name);
+            this.required.clear();
+            for (const name of pending) {
+                if (this.required.has(name))
+                    continue;
+                this.required.add(name);
+                const entry = byModule.get(name);
+                const baseUrl = entry?.parent.tree.ctx.baseUrl;
+                if (baseUrl === undefined || !name.startsWith('@'))
+                    continue;
+                const packageName = name.split('/').slice(0, 2).join('/');
+                const manifest = createRequire(baseUrl).resolve(`${packageName}/package.json`);
+                const metadata = zod.object({ dependencies: zod.record(zod.string(), zod.string()).optional(), peerDependencies: zod.record(zod.string(), zod.string()).optional(), hydra: zod.object({ bundle: zod.unknown().optional() }).optional() }).parse(JSON.parse(await readFile(manifest, 'utf8')));
+                // Bundle manifests list optional composition rows; required runtime rows carry their own flags.
+                if (metadata.hydra?.bundle !== undefined)
+                    continue;
+                for (const dependency of Object.keys({ ...metadata.dependencies, ...metadata.peerDependencies })) {
+                    for (const candidate of entries)
+                        if (candidate.options.name === dependency || candidate.options.name.startsWith(`${dependency}/`))
+                            pending.push(candidate.options.name);
+                }
+            }
+            for (const entry of entries) {
+                if (entry.subtree !== undefined || entry.subgroup !== undefined || this.required.has(entry.options.name))
+                    continue;
+                const previous = this.suspended.get(entry);
+                if (!enabled) {
+                    if (!this.suspended.has(entry))
+                        this.suspended.set(entry, !entry.disabled);
+                    await entry.update({ disabled: true });
+                }
+                else if (previous !== undefined) {
+                    const nextEnabled = this.isRestartOnly(entry) ? previous
+                        : this.settings.get().enabled[entry.options.name] ?? this.defaultEnabled.get(entry.options.name) ?? previous;
+                    this.suspended.delete(entry);
+                    await entry.update({ disabled: !nextEnabled });
+                }
+            }
+        }
+        rootInclude() {
+            return Object.values(this.ctx.loader.store)
+                .map(entry => entry.subtree)
+                .find((tree) => tree !== undefined
+                && 'filename' in tree
+                && typeof tree.filename === 'string');
+        }
+        /** Project persisted OpenAI/Codex marketplace sources without exposing their entries here. */
+        async marketplaceSnapshot() {
+            const sources = this.marketplaceSettings.get().sources;
+            if (sources.length === 0)
+                return { marketplaces: [] };
+            const marketplaces = [];
+            for (const source of sources) {
+                const sourceView = {
+                    source: source.source,
+                    ...(source.gitRef === '' ? {} : { gitRef: source.gitRef }),
+                    sparsePaths: source.sparsePaths,
+                    enabled: source.enabled,
+                };
+                try {
+                    await loadMarketplace(source);
+                    marketplaces.push({ status: 'ready', ...sourceView });
+                }
+                catch {
+                    marketplaces.push({ status: 'unavailable', ...sourceView });
+                }
+            }
+            return { marketplaces };
+        }
+        moduleEntries(moduleName) {
+            const entries = [];
+            for (const entry of this.ctx.loader.entries()) {
+                if (!entry.options.group
+                    && !this.compositionEntryIds.has(entry.options.id)
+                    && entry.options.name === moduleName)
+                    entries.push(entry);
+            }
+            return entries;
+        }
+        /** One logical row per module, preferring the profile-owned entry. */
+        representatives(rootInclude) {
+            const entries = new Map();
+            for (const entry of this.ctx.loader.entries()) {
+                if (entry.options.group || this.compositionEntryIds.has(entry.options.id))
+                    continue;
+                this.isRestartOnly(entry);
+                if (entry.options.pluginRequired !== undefined && typeof entry.options.pluginRequired !== 'boolean')
+                    throw new Error(`pluginInventory: ${entry.id}.pluginRequired must be boolean`);
+                const group = entry.options.pluginGroup;
+                if (group !== undefined && (typeof group !== 'string' || group.trim() === '')) {
+                    throw new Error(`pluginInventory: ${entry.id}.pluginGroup must be a non-empty string`);
+                }
+                if ('plugin_type' in entry.options)
+                    throw new Error(`pluginInventory: ${entry.id}.plugin_type: use pluginType`);
+                const current = entries.get(entry.options.name);
+                if (current === undefined
+                    || (entry.parent.tree === rootInclude && current.parent.tree !== rootInclude)
+                    || (this.isRestartOnly(entry) && !this.isRestartOnly(current))) {
+                    entries.set(entry.options.name, entry);
+                }
+            }
+            return entries;
+        }
+        /** Whether changing this root entry must wait for the next profile boot. */
+        isRestartOnly(entry) {
+            const value = entry.options.pluginType;
+            if (value !== undefined && value !== 'core' && value !== 'normal') {
+                throw new Error(`pluginInventory: ${entry.id}.pluginType must be core or normal`);
+            }
+            return value === 'core' || (entry.options.pluginGroup !== undefined
+                && [...this.ctx.loader.entries()].some(candidate => candidate.options.pluginGroup === entry.options.pluginGroup
+                    && candidate.options.pluginType === 'core'));
+        }
+        isToggleable(entry, rootInclude = this.rootInclude()) {
+            return rootInclude !== undefined
+                && entry.parent.tree === rootInclude
+                && entry.options.pluginRequired !== true && !this.required.has(entry.options.name);
+        }
+        enabled(entry) {
+            if (this.isRestartOnly(entry) || !this.isToggleable(entry))
+                return this.suspended.get(entry) ?? !entry.disabled;
+            return this.settings.get().enabled[entry.options.name]
+                ?? this.defaultEnabled.get(entry.options.name)
+                ?? !entry.disabled;
+        }
+        /** Desired state used by the switch; restart-only entries retain the live Loader state until reboot. */
+        desiredEnabled(entry) {
+            return this.isRestartOnly(entry)
+                ? this.restartEnablement[entry.options.id] ?? !entry.disabled
+                : this.enabled(entry);
+        }
+        /** Whether the currently loaded entry still differs from its persisted desired state. */
+        restartRequired(entry) {
+            const pending = this.restartEnablement[entry.options.id];
+            return this.isRestartOnly(entry) && pending !== undefined && pending !== !entry.disabled;
+        }
+        /** Resolve the active root Include to the profile directory the launcher owns. */
+        profileDir() {
+            const filename = this.rootInclude()?.filename;
+            /* v8 ignore next -- Restart updates only follow a synchronous rootInclude-backed toggleability check. */
+            if (typeof filename !== 'string')
+                throw new Error('pluginInventory: active profile root is unavailable');
+            /* v8 ignore next -- The root Include stores filename as the filesystem path returned by fileURLToPath. */
+            const path = filename.startsWith('file:') ? fileURLToPath(filename) : filename;
+            const actual = resolve(dirname(path));
+            const expected = resolve(resolveProfileDir(basename(actual)));
+            if (actual !== expected) {
+                throw new Error(`pluginInventory: active root ${path} is not a managed hydra profile`);
+            }
+            return expected;
+        }
+        /** Persist one restart-only root switch without changing the live Loader tree. */
+        async setRestartEnabled(entries, enabled) {
+            const profileDir = this.profileDir();
+            const manifestPath = join(profileDir, 'package.json');
+            await withFileLock(manifestPath, async () => {
+                // Re-read while holding the cross-process lock so a concurrent profile
+                // edit cannot be replaced by a stale manifest snapshot.
+                const manifest = readProfileManifest('pluginInventory', profileDir);
+                const pluginEnablement = {
+                    ...profilePluginEnablement(manifest),
+                    ...Object.fromEntries(entries.map(entry => [entry.options.id, enabled])),
+                };
+                const next = {
+                    ...manifest,
+                    hydra: {
+                        ...manifest.hydra,
+                        profile: {
+                            ...manifest.hydra?.profile,
+                            pluginEnablement,
+                        },
+                    },
+                };
+                await writeFileAtomic(manifestPath, `${JSON.stringify(next, undefined, 2)}\n`, { mode: 0o600 });
+                this.restartEnablement = pluginEnablement;
+            });
+        }
+        isHmrWatchOnly(entry) {
+            const config = entry.options.config;
+            return entry.options.name === HMR_MODULE && Array.isArray(config?.root) && config.root.length === 0;
+        }
+        enqueue(task) {
+            const run = this.mutationTail.then(task, task);
+            this.mutationTail = run.then(() => undefined, () => undefined);
+            return run;
+        }
+        async restore(states) {
+            for (const state of states.toReversed()) {
+                await state.entry.update({
+                    disabled: state.disabled ?? null,
+                    config: state.config ?? null,
+                });
+            }
+        }
+        /** Keep one configured instance active; HMR's disabled state remains watch-only. */
+        async updateModule(entry, enabled) {
+            const candidates = this.moduleEntries(entry.options.name);
+            const states = candidates.map(candidate => ({
+                entry: candidate,
+                disabled: candidate.options.disabled,
+                config: candidate.options.config,
+            }));
+            try {
+                for (const candidate of candidates) {
+                    if (candidate !== entry && !candidate.disabled)
+                        await candidate.update({ disabled: true });
+                }
+                if (entry.options.name === HMR_MODULE) {
+                    const original = this.originalConfigs.get(entry.options.name);
+                    const config = { ...original };
+                    if (enabled)
+                        delete config.root;
+                    else
+                        config.root = [];
+                    await entry.update({ disabled: null, config });
+                }
+                else {
+                    await entry.update({ disabled: enabled ? null : true });
+                }
+                return states;
+            }
+            catch (error) {
+                try {
+                    await this.restore(states);
+                }
+                catch (rollbackError) {
+                    throw new AggregateError([error, rollbackError], `pluginInventory: failed to update and roll back ${entry.options.name}`);
+                }
+                throw error;
+            }
+        }
+        async applySettings(enabled) {
+            const rootInclude = this.rootInclude();
+            const representatives = this.representatives(rootInclude);
+            const modules = new Set([...this.appliedSettings, ...Object.keys(enabled)]);
+            this.appliedSettings.clear();
+            for (const moduleName of Object.keys(enabled))
+                this.appliedSettings.add(moduleName);
+            const failures = [];
+            for (const moduleName of modules) {
+                const entry = representatives.get(moduleName);
+                if (entry === undefined)
+                    continue;
+                if (!this.isToggleable(entry, rootInclude) || this.isRestartOnly(entry))
+                    continue;
+                const desired = enabled[moduleName]
+                    ?? this.defaultEnabled.get(moduleName)
+                    ?? !entry.disabled;
+                try {
+                    await this.updateModule(entry, this.ctx.get('optionalPlugins')?.enabled === false && !this.required.has(moduleName) ? false : desired);
+                }
+                catch (error) {
+                    failures.push(error);
+                }
+            }
+            if (failures.length === 1)
+                throw failures[0];
+            if (failures.length > 1)
+                throw new AggregateError(failures, 'pluginInventory: failed to apply plugin settings');
+        }
+        /**
+         * Read the Loader and optional preset roster directly on every call. Cordis's
+         * internal plugin/status events already maintain Entry.fiber and Fiber state,
+         * so a second Host cache would only add another lifecycle truth to synchronize.
+         * @returns Current Host entries followed by preset-owned leaf entries.
+         */
+        async hostEntries() {
+            const rootInclude = this.rootInclude();
+            return Promise.all(this.inventoryGroups(rootInclude).map(async (group) => {
+                const entry = group[0];
+                const members = group.filter(candidate => this.isToggleable(candidate, rootInclude));
+                const controlled = members.length > 0 ? members : group;
+                const initialStates = controlled.map(candidate => this.initialEnabled.get(candidate.id) ?? this.enabled(candidate));
+                const desiredStates = controlled.map(candidate => this.desiredEnabled(candidate));
+                const enabled = controlled.every(candidate => this.enabled(candidate));
+                const restartRequired = controlled.some(candidate => this.restartRequired(candidate));
+                const pendingEnabled = restartRequired ? controlled.every(candidate => this.desiredEnabled(candidate)) : undefined;
+                const active = enabled
+                    ? this.moduleEntries(entry.options.name).find(candidate => !candidate.disabled && candidate.fiber !== undefined)
+                    : undefined;
+                const fiber = active?.fiber;
+                return {
+                    entryId: pluginEntryId(entry.id),
+                    moduleName: entry.options.name,
+                    ...await pluginMetadata(entry.options.name, entry.parent.tree.ctx.baseUrl, entry.options),
+                    pluginType: group.some(candidate => this.isRestartOnly(candidate)) ? 'core' : 'normal',
+                    ...entry.options.pluginRequired === true || this.required.has(entry.options.name) ? { required: true } : {},
+                    initialEnabled: initialStates.every(Boolean) ? true : initialStates.some(Boolean) ? null : false,
+                    changedSinceStart: controlled.some((candidate, index) => this.desiredEnabled(candidate) !== initialStates[index]),
+                    ...(desiredStates.some(Boolean) && !desiredStates.every(Boolean) ? { mixedEnabled: true } : {}),
+                    ...(group.length > 1 ? { relatedModules: group.slice(1).map(candidate => candidate.options.name) } : {}),
+                    enabled,
+                    ...pendingEnabled === undefined ? {} : { pendingEnabled },
+                    restartRequired,
+                    toggleable: this.isToggleable(entry, rootInclude),
+                    fiberPhase: fiber === undefined ? null : FIBER_PHASE[fiber.state],
+                };
+            }));
+        }
+        async presetEntries(presets, settings, target = {}) {
+            if (presets === undefined)
+                return [];
+            const entries = settings === undefined ? await presets.listPluginEntries() : await presets.listPluginEntries(settings);
+            return Promise.all(entries.map(async (entry) => ({
+                entryId: pluginEntryId(entry.entryId),
+                moduleName: entry.moduleName,
+                ...await pluginMetadata(entry.moduleName, this.ctx.baseUrl, entry),
+                enabled: entry.enabled,
+                presetId: entry.presetId,
+                ...entry.rowId === undefined ? {} : { presetRowId: entry.rowId },
+                newSessionsOnly: true,
+                initialEnabled: this.initialEnabled.get(this.initialKey(entry.entryId, target)) ?? entry.enabled,
+                restartRequired: false,
+                toggleable: true,
+                fiberPhase: null,
+            })));
+        }
+        /**
+         * List Host entries and preset leaves, or only the selected workspace's preset leaves.
+         * @param request - Workspace and editable settings layer; omission selects global inventory.
+         * @returns the current inventory projection.
+         */
+        async list(request) {
+            const target = request ?? {};
+            this.assertTarget(target);
+            const workspace = target.workspaceId === undefined ? undefined : await this.workspaceTarget(target.workspaceId, target.layer);
+            const selected = workspace?.target ?? {};
+            const entries = workspace === undefined
+                ? [...await this.hostEntries(), ...await this.presetEntries(this.agentPresets())]
+                : await this.presetEntries(workspace.presets, workspace.settings, selected);
+            for (const entry of entries) {
+                const key = this.initialKey(entry.entryId, selected);
+                if (!this.initialEnabled.has(key))
+                    this.initialEnabled.set(key, entry.enabled);
+            }
+            return { entries, ...selected };
+        }
+        /** Keep initial preset states separate for global and workspace settings files. */
+        initialKey(entryId, target) {
+            return target.workspaceId === undefined ? entryId : `${target.workspaceId}:${target.layer ?? 'local'}:${entryId}`;
+        }
+        /** Group only explicitly related entries, preferring a persistently editable owner. */
+        inventoryGroups(rootInclude) {
+            const groups = new Map();
+            for (const entry of this.representatives(rootInclude).values()) {
+                const key = entry.options.pluginGroup === undefined ? `module:${entry.options.name}`
+                    : `group:${entry.options.pluginGroup}:${entry.options.pluginRequired === true || this.required.has(entry.options.name) ? 'required' : 'optional'}`;
+                const group = groups.get(key) ?? [];
+                if (this.isToggleable(entry, rootInclude) && group[0] !== undefined && !this.isToggleable(group[0], rootInclude))
+                    group.unshift(entry);
+                else
+                    group.push(entry);
+                groups.set(key, group);
+            }
+            return [...groups.values()];
+        }
+        /**
+         * Persist a restart-only root state without live unload, or apply one normal
+         * module-wide live state and persist it in the shared settings document.
+         * @param request - Target entry, desired enablement, and optional workspace settings file.
+         * @returns The fresh snapshot and whether this mutation needs a restart.
+         */
+        setEnabled(request) {
+            this.assertTarget(request);
+            return this.enqueue(async () => {
+                const workspace = request.workspaceId === undefined ? undefined : await this.workspaceTarget(request.workspaceId, request.layer);
+                if (workspace !== undefined && !request.entryId.startsWith(AGENT_PRESET_ENTRY_PREFIX)) {
+                    throw new Error('pluginInventory: workspace settings can change only agent preset entries');
+                }
+                if (request.entryId.startsWith(AGENT_PRESET_ENTRY_PREFIX)) {
+                    const presets = workspace === undefined ? this.agentPresets() : workspace.presets;
+                    if (presets === undefined) {
+                        throw new Error('pluginInventory: agent preset controls are unavailable');
+                    }
+                    const entries = workspace === undefined ? await presets.listPluginEntries() : await presets.listPluginEntries(workspace.settings);
+                    const entry = entries
+                        .find(candidate => candidate.entryId === request.entryId);
+                    if (entry === undefined) {
+                        throw new Error(`pluginInventory: preset entry ${request.entryId} cannot be toggled in-app`);
+                    }
+                    const key = this.initialKey(entry.entryId, workspace?.target ?? {});
+                    if (!this.initialEnabled.has(key))
+                        this.initialEnabled.set(key, entry.enabled);
+                    if (entry.enabled !== request.enabled) {
+                        if (workspace === undefined)
+                            await presets.setPluginEnabled(entry.entryId, request.enabled);
+                        else
+                            await presets.setPluginEnabled(entry.entryId, request.enabled, workspace.settings);
+                    }
+                    return { snapshot: await this.list(workspace?.target), restartRequired: false };
+                }
+                const resolved = this.ctx.loader.resolve(request.entryId);
+                const rootInclude = this.rootInclude();
+                const group = this.inventoryGroups(rootInclude)
+                    .find(candidates => candidates.some(candidate => candidate.options.name === resolved.options.name)) ?? [];
+                const entry = group[0];
+                if (entry === undefined || !this.isToggleable(entry, rootInclude)) {
+                    throw new Error(`pluginInventory: entry ${request.entryId} cannot be toggled in-app`);
+                }
+                const members = group.filter(candidate => this.isToggleable(candidate, rootInclude));
+                if (members.every(candidate => request.enabled === this.desiredEnabled(candidate))) {
+                    return { snapshot: await this.list(), restartRequired: members.some(candidate => this.restartRequired(candidate)) };
+                }
+                if (group.some(candidate => this.isRestartOnly(candidate))) {
+                    await this.setRestartEnabled(members, request.enabled);
+                    return { snapshot: await this.list(), restartRequired: members.some(candidate => this.restartRequired(candidate)) };
+                }
+                const states = [];
+                try {
+                    for (const member of members)
+                        states.push(...await this.updateModule(member, request.enabled));
+                    await this.settings.update({ enabled: Object.fromEntries(members.map(member => [member.options.name, request.enabled])) });
+                }
+                catch (error) {
+                    try {
+                        await this.restore(states);
+                    }
+                    catch (rollbackError) {
+                        throw new AggregateError([error, rollbackError], `pluginInventory: failed to persist and roll back ${request.entryId}`);
+                    }
+                    throw error;
+                }
+                return { snapshot: await this.list(), restartRequired: false };
+            });
+        }
+        /**
+         * Project every persisted OpenAI/Codex marketplace source.
+         * @returns OpenAI/Codex marketplace sources in persisted order.
+         */
+        listMarketplaces() {
+            return this.marketplaceSnapshot();
+        }
+        /**
+         * Persist one validated OpenAI/Codex marketplace source, replacing any source of the same location.
+         * @param request - marketplace location with its optional Git ref and sparse paths.
+         * @returns The refreshed OpenAI/Codex marketplace source list.
+         */
+        addMarketplace(request) {
+            return this.enqueue(async () => {
+                const loaded = await loadMarketplace(request);
+                const sources = this.marketplaceSettings.get().sources;
+                const existing = sources.findIndex(source => source.source === loaded.source.source);
+                const entry = { ...loaded.source, enabled: sources[existing]?.enabled ?? true };
+                const next = existing === -1
+                    ? [...sources, entry]
+                    : sources.map((source, index) => index === existing ? entry : source);
+                await this.marketplaceSettings.update({ sources: next });
+                return this.marketplaceSnapshot();
+            });
+        }
+        /**
+         * Enable or disable one marketplace slot, cascading to its imported plugins.
+         * @param request - marketplace source and its desired enablement.
+         * @returns The refreshed OpenAI/Codex marketplace source list.
+         */
+        setMarketplaceEnabled(request) {
+            return this.enqueue(async () => {
+                const sources = this.marketplaceSettings.get().sources;
+                const index = sources.findIndex(candidate => candidate.source === request.source);
+                if (index === -1)
+                    throw new Error(`pluginInventory: marketplace ${request.source} is not configured`);
+                const next = sources.map((candidate, position) => position === index
+                    ? { ...candidate, enabled: request.enabled }
+                    : candidate);
+                await this.marketplaceSettings.update({ sources: next });
+                await this.cascadeMarketplacePlugins(request.source, (runtime, identity) => request.enabled ? runtime.enable(identity) : runtime.disable(identity));
+                return this.marketplaceSnapshot();
+            });
+        }
+        /**
+         * Remove one persisted OpenAI/Codex marketplace source and uninstall its imported plugins.
+         * @param source - the persisted marketplace location to delete.
+         * @returns The refreshed OpenAI/Codex marketplace source list.
+         */
+        removeMarketplace(source) {
+            return this.enqueue(async () => {
+                if (!this.marketplaceSettings.get().sources.some(candidate => candidate.source === source)) {
+                    throw new Error(`pluginInventory: marketplace ${source} is not configured`);
+                }
+                await this.cascadeMarketplacePlugins(source, (runtime, identity) => runtime.remove(identity));
+                const next = this.marketplaceSettings.get().sources.filter(candidate => candidate.source !== source);
+                await this.marketplaceSettings.update({ sources: next });
+                return await this.marketplaceSnapshot();
+            });
+        }
+        /**
+         * Apply one lifecycle action to every plugin imported from this marketplace root.
+         * A no-op when the imported-plugin runtime is not part of this composition.
+         */
+        async cascadeMarketplacePlugins(marketplace, action) {
+            const runtime = this.ctx.get('importedPlugins');
+            if (runtime === undefined)
+                return;
+            const plugins = (await runtime.list()).plugins.filter(plugin => plugin.source.marketplace === marketplace);
+            const failures = [];
+            for (const plugin of plugins) {
+                try {
+                    await action(runtime, plugin.identity);
+                }
+                catch (error) {
+                    failures.push(error);
+                }
+            }
+            if (failures.length === 1)
+                throw failures[0];
+            if (failures.length > 1) {
+                throw new AggregateError(failures, `pluginInventory: failed to update plugins for marketplace ${marketplace}`);
+            }
+        }
+        /**
+         * List source-qualified imported OpenAI/Codex plugin bundles.
+         * @returns Current imported-plugin projection.
+         */
+        listImportedPlugins() {
+            return this.importedPlugins().list();
+        }
+        /**
+         * Stage a direct local/Git source or marketplace bundle through the shared runtime.
+         * @param source - Plugin source to import.
+         * @returns Current imported-plugin projection.
+         */
+        importPlugin(source) {
+            return this.importedPlugins().import(source);
+        }
+        /**
+         * Read one imported bundle by source-qualified identity or an unambiguous name.
+         * @param identityOrName - Source-qualified identity or unambiguous plugin name.
+         * @returns Current plugin projection.
+         */
+        infoPlugin(identityOrName) {
+            return this.importedPlugins().info(identityOrName);
+        }
+        /**
+         * Enable and load one imported bundle without changing native Hydra package state.
+         * @param identityOrName - Source-qualified identity or unambiguous plugin name.
+         * @returns Current imported-plugin projection.
+         */
+        enablePlugin(identityOrName) {
+            return this.importedPlugins().enable(identityOrName);
+        }
+        /**
+         * Disable and deterministically unload one imported bundle.
+         * @param identityOrName - Source-qualified identity or unambiguous plugin name.
+         * @returns Current imported-plugin projection.
+         */
+        disablePlugin(identityOrName) {
+            return this.importedPlugins().disable(identityOrName);
+        }
+        /**
+         * Change one imported plugin MCP server without changing hook trust.
+         * @param request - plugin identity, server name, and desired enablement.
+         * @returns Current imported-plugin projection.
+         */
+        setPluginMcpServerEnabled(request) {
+            return this.importedPlugins().setMcpServerEnabled(request.identity, request.server, request.enabled);
+        }
+        /**
+         * Set one imported MCP tool's approval mode without changing server enablement.
+         * @param request - Plugin identity, server, tool, and approval mode.
+         * @returns Current imported-plugin projection.
+         */
+        setPluginMcpToolApproval(request) {
+            return this.importedPlugins().setMcpToolApproval(request.identity, request.server, request.tool, request.approval);
+        }
+        /**
+         * Trust only the current hook definitions; MCP/tool approval remains independent.
+         * @param identityOrName - Source-qualified identity or unambiguous plugin name.
+         * @returns Current imported-plugin projection.
+         */
+        trustPlugin(identityOrName) {
+            return this.importedPlugins().trustHooks(identityOrName);
+        }
+        /**
+         * Revoke hook trust without disabling other plugin components.
+         * @param identityOrName - Source-qualified identity or unambiguous plugin name.
+         * @returns Current imported-plugin projection.
+         */
+        untrustPlugin(identityOrName) {
+            return this.importedPlugins().untrustHooks(identityOrName);
+        }
+        /**
+         * Remove one imported bundle and its writable plugin data.
+         * @param identityOrName - Source-qualified identity or unambiguous plugin name.
+         * @returns Current imported-plugin projection.
+         */
+        removePlugin(identityOrName) {
+            return this.importedPlugins().remove(identityOrName);
+        }
+        /**
+         * List the user's own MCP server records with their live state.
+         * @param request - Workspace to inspect; omission selects the user's global records.
+         * @returns Selected settings records with runtime status and the workspace target.
+         */
+        listMcpServers(request) {
+            const target = request ?? {};
+            this.assertTarget(target);
+            if (target.workspaceId !== undefined) {
+                return this.workspaceTarget(target.workspaceId, target.layer)
+                    .then(({ ctx, settings, target: selected }) => ({ ...this.mcpServers(ctx).list(settings), ...selected }));
+            }
+            return Promise.resolve(this.mcpServers().list());
+        }
+        /**
+         * Store one complete MCP server definition and converge its mount.
+         * @param request - Complete server definition and optional workspace file to edit.
+         * @returns Refreshed MCP record projection.
+         */
+        defineMcpServer(request) {
+            this.assertTarget(request);
+            if (request.workspaceId !== undefined) {
+                return this.workspaceTarget(request.workspaceId, request.layer).then(async ({ ctx, settings, target }) => {
+                    const registry = this.mcpServers(ctx);
+                    await registry.define(request, settings);
+                    return { ...registry.list(settings), ...target };
+                });
+            }
+            return this.mcpServers().define(request);
+        }
+        /**
+         * Change one MCP record's desired state without touching its definition.
+         * @param request - Target record, desired state, and optional workspace file to edit.
+         * @returns Refreshed MCP record projection.
+         */
+        setMcpServerEnabled(request) {
+            this.assertTarget(request);
+            if (request.workspaceId !== undefined) {
+                return this.workspaceTarget(request.workspaceId, request.layer).then(async ({ ctx, settings, target }) => {
+                    const registry = this.mcpServers(ctx);
+                    await registry.setEnabled(request, settings);
+                    return { ...registry.list(settings), ...target };
+                });
+            }
+            return this.mcpServers().setEnabled(request);
+        }
+        /**
+         * Remove one MCP record and unmount its server.
+         * @param request - Stored record name and optional workspace file to edit; a string selects global records.
+         * @returns Refreshed MCP record projection.
+         */
+        removeMcpServer(request) {
+            if (typeof request !== 'string')
+                this.assertTarget(request);
+            if (typeof request !== 'string' && request.workspaceId !== undefined) {
+                return this.workspaceTarget(request.workspaceId, request.layer).then(async ({ ctx, settings, target }) => {
+                    const registry = this.mcpServers(ctx);
+                    await registry.remove(request.name, settings);
+                    return { ...registry.list(settings), ...target };
+                });
+            }
+            return this.mcpServers().remove(typeof request === 'string' ? request : request.name);
+        }
+        /**
+         * List the user's own hook records with their live state.
+         * @param request - Workspace to inspect; omission selects the user's global records.
+         * @returns Selected settings records with runtime status and the workspace target.
+         */
+        listHookRecords(request) {
+            const target = request ?? {};
+            this.assertTarget(target);
+            if (target.workspaceId !== undefined) {
+                return this.workspaceTarget(target.workspaceId, target.layer)
+                    .then(({ ctx, settings, target: selected }) => ({ ...this.hookRecords(ctx).list(settings), ...selected }));
+            }
+            return Promise.resolve(this.hookRecords().list());
+        }
+        /**
+         * Store one complete hook record definition and converge its bridge mount.
+         * @param request - Complete record definition and optional workspace file to edit.
+         * @returns Refreshed hook record projection.
+         */
+        defineHookRecord(request) {
+            this.assertTarget(request);
+            if (request.workspaceId !== undefined) {
+                return this.workspaceTarget(request.workspaceId, request.layer).then(async ({ ctx, settings, target }) => {
+                    const registry = this.hookRecords(ctx);
+                    await registry.define(request, settings);
+                    return { ...registry.list(settings), ...target };
+                });
+            }
+            return this.hookRecords().define(request);
+        }
+        /**
+         * Change one hook record's desired state without touching its definition.
+         * @param request - Target record, desired state, and optional workspace file to edit.
+         * @returns Refreshed hook record projection.
+         */
+        setHookRecordEnabled(request) {
+            this.assertTarget(request);
+            if (request.workspaceId !== undefined) {
+                return this.workspaceTarget(request.workspaceId, request.layer).then(async ({ ctx, settings, target }) => {
+                    const registry = this.hookRecords(ctx);
+                    await registry.setEnabled(request, settings);
+                    return { ...registry.list(settings), ...target };
+                });
+            }
+            return this.hookRecords().setEnabled(request);
+        }
+        /**
+         * Remove one hook record and unmount its bridge.
+         * @param request - Stored record name and optional workspace file to edit; a string selects global records.
+         * @returns Refreshed hook record projection.
+         */
+        removeHookRecord(request) {
+            if (typeof request !== 'string')
+                this.assertTarget(request);
+            if (typeof request !== 'string' && request.workspaceId !== undefined) {
+                return this.workspaceTarget(request.workspaceId, request.layer).then(async ({ ctx, settings, target }) => {
+                    const registry = this.hookRecords(ctx);
+                    await registry.remove(request.name, settings);
+                    return { ...registry.list(settings), ...target };
+                });
+            }
+            return this.hookRecords().remove(typeof request === 'string' ? request : request.name);
+        }
+        /** Reject a workspace file selector that cannot identify a workspace. */
+        assertTarget(target) {
+            if (target.workspaceId === undefined && target.layer !== undefined) {
+                throw new Error('pluginInventory: layer requires workspaceId');
+            }
+        }
+        /** Resolve one workspace's runtime services and selected editable settings file. */
+        async workspaceTarget(workspaceId, layer = 'local') {
+            const service = this.ctx.get('workspaceConfig');
+            if (service === undefined)
+                throw new Error('pluginInventory: workspace configuration is unavailable');
+            const environment = await service.environmentFor(workspaceId);
+            const settings = await service.settingsFor(workspaceId, layer);
+            return { ctx: environment.ctx, presets: environment.presets, settings, target: { workspaceId, layer } };
+        }
+        importedPlugins() {
+            const runtime = this.ctx.get('importedPlugins');
+            if (runtime === undefined)
+                throw new Error('pluginInventory: imported plugin runtime is unavailable');
+            return runtime;
+        }
+        /** The MCP record registry is optional in compositions without user MCP servers. */
+        mcpServers(ctx = this.ctx) {
+            const registry = ctx.get('mcpServers');
+            if (registry === undefined)
+                throw new Error('pluginInventory: MCP server registry is unavailable');
+            return registry;
+        }
+        /** The hook record registry is optional in compositions without user hooks. */
+        hookRecords(ctx = this.ctx) {
+            const registry = ctx.get('hookRecords');
+            if (registry === undefined)
+                throw new Error('pluginInventory: hook record registry is unavailable');
+            return registry;
+        }
+        /** Agent-preset ownership is optional in headless and non-roster compositions. */
+        agentPresets() {
+            return this.ctx.get('agentPresets');
+        }
+    };
+})();
+export { PluginInventoryGateway };
+export default PluginInventoryGateway;
+//# sourceMappingURL=index.js.map