@jini-ai/agent-plugins 0.4.0

package/dist/lifecycle/resolve-agent-plugin-refs.d.ts

@@ -0,0 +1,18 @@
+import type { AgentPluginDeliveryMode, InstalledAgentPlugin } from "./types.js";
+import type { AgentPluginWorkspaceLayout } from "./layout.js";
+import type { AgentPluginLifecyclePorts } from "./ports.js";
+export type { AgentPluginDeliveryMode } from "./types.js";
+export type ResolveAgentPluginRefsResult = {
+    readonly ok: true;
+    readonly promptPrefix: string;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+/** Internal composition; one state/queue instance per injected host context. */
+export declare function createResolveAgentPluginRefsModule(ports: AgentPluginLifecyclePorts): {
+    resolveAgentPluginRefs: (pluginRefIds: readonly string[], workspaceLayout: Pick<AgentPluginWorkspaceLayout, "packages" | "root">, deliveryMode?: AgentPluginDeliveryMode) => Promise<ResolveAgentPluginRefsResult>;
+    listInstalledPlugins: (packagesDir: string) => Promise<readonly InstalledAgentPlugin[]>;
+    isInstalledDigestPresent: (packagesDir: string, archiveDigest: string) => Promise<boolean>;
+};
+//# sourceMappingURL=resolve-agent-plugin-refs.d.ts.map

package/dist/lifecycle/resolve-agent-plugin-refs.js

@@ -0,0 +1,143 @@
+/** Extracted from the host plugin lifecycle. Effects are supplied per host context. */
+import path from "node:path";
+import {} from "./activation.js";
+import { createActivationModule } from "./activation.js";
+import {} from "./bundled-digests.js";
+import { createBundledDigestsModule } from "./bundled-digests.js";
+import { createInstallModule } from "./install.js";
+import { createCapabilityProjectionModule } from "./capability-projection.js";
+function buildModule(ports) {
+    const readdir = ports.filesystem.readdir.bind(ports.filesystem);
+    const stat = ports.filesystem.stat.bind(ports.filesystem);
+    const { resolveAgentPluginActivation } = createActivationModule(ports);
+    const { preferBundledAgentPluginDigests, readBundledAgentPluginDigests } = createBundledDigestsModule(ports);
+    const { indexInstalledRoot } = createInstallModule(ports);
+    const { readInstalledSkillMarkdown } = createCapabilityProjectionModule(ports);
+    const SHA256_DIGEST_DIRNAME_PATTERN = /^[a-f0-9]{64}$/;
+    function resolveAgentPluginDeliveryMode() { return ports.deliveryMode; }
+    async function resolveAgentPluginRefs(pluginRefIds, workspaceLayout, deliveryMode = resolveAgentPluginDeliveryMode()) {
+        if (pluginRefIds.length === 0)
+            return { ok: true, promptPrefix: "" };
+        const bundledDigests = await readBundledAgentPluginDigests(workspaceLayout.root);
+        const sections = [];
+        for (const pluginRefId of pluginRefIds) {
+            const refusal = activationRefusal(pluginRefId, await resolveAgentPluginActivation(workspaceLayout.root, pluginRefId));
+            if (refusal !== undefined)
+                return { ok: false, reason: refusal };
+            const resolved = await resolveOnePluginRef(pluginRefId, workspaceLayout.packages, deliveryMode, bundledDigests);
+            if (!resolved.ok)
+                return resolved;
+            sections.push(resolved.section);
+        }
+        return { ok: true, promptPrefix: sections.join("\n\n") };
+    }
+    function activationRefusal(pluginRefId, verdict) {
+        if (verdict.verdict === "active")
+            return undefined;
+        if (verdict.verdict === "undetermined") {
+            return (`Agent Plugin '${pluginRefId}' was not loaded: this workspace's activation record could not be read, so whether ` +
+                `it is enabled cannot be confirmed (${verdict.reason}). Nothing was injected; repair activations.json and start the run again.`);
+        }
+        return (`Agent Plugin '${pluginRefId}' is installed in this workspace but is not enabled — it ships with ${ports.productName} and ` +
+            "stays inactive until an operator turns it on. Enable it before pinning it to a run.");
+    }
+    async function listInstalledPlugins(packagesDir) {
+        let entries;
+        try {
+            entries = await readdir(packagesDir);
+        }
+        catch (error) {
+            if (isEnoent(error))
+                return [];
+            throw error;
+        }
+        const installed = [];
+        for (const digest of entries) {
+            if (!SHA256_DIGEST_DIRNAME_PATTERN.test(digest))
+                continue;
+            try {
+                installed.push(await indexInstalledRoot(path.join(packagesDir, digest), digest));
+            }
+            catch {
+            }
+        }
+        return installed;
+    }
+    async function isInstalledDigestPresent(packagesDir, archiveDigest) {
+        if (!SHA256_DIGEST_DIRNAME_PATTERN.test(archiveDigest))
+            return false;
+        try {
+            return (await stat(path.join(packagesDir, archiveDigest))).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
+    function isEnoent(error) {
+        return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+    }
+    async function resolveOnePluginRef(pluginRefId, packagesDir, deliveryMode, bundledDigests) {
+        const installed = preferBundledAgentPluginDigests(await listInstalledPlugins(packagesDir), bundledDigests);
+        const matches = installed.filter((plugin) => plugin.pluginId === pluginRefId);
+        if (matches.length === 0) {
+            return {
+                ok: false,
+                reason: `Agent Plugin '${pluginRefId}' is not installed in this workspace — pinned by the composer but not found under any installed package`,
+            };
+        }
+        if (matches.length > 1) {
+            const digests = matches.map((plugin) => plugin.archiveDigest).sort();
+            return {
+                ok: false,
+                reason: `Agent Plugin '${pluginRefId}' matches ${matches.length} installed packages (digests: ${digests.join(", ")}) — refusing to guess which one to use`,
+            };
+        }
+        const plugin = matches[0];
+        const skillPath = `skills/${pluginRefId}/SKILL.md`;
+        if (deliveryMode === "pointer")
+            return buildPointerSection(pluginRefId, plugin);
+        let skillMarkdown;
+        try {
+            skillMarkdown = await readInstalledSkillMarkdown(plugin.packageRoot, skillPath);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                ok: false,
+                reason: `Agent Plugin '${pluginRefId}' has no readable '${skillPath}' in its installed package: ${message}`,
+            };
+        }
+        const otherFiles = plugin.files
+            .filter((file) => file !== skillPath)
+            .map((file) => path.join(plugin.packageRoot, file));
+        const inventory = otherFiles.length > 0
+            ? `\n\nThe SKILL.md above is this Agent Plugin's own instructions — follow them, including any files it directs you to load before starting work. Every other file in the installed package is listed below by absolute path and is readable now:\n${otherFiles.map((file) => `- ${file}`).join("\n")}`
+            : "";
+        return {
+            ok: true,
+            section: `<<AGENT_PLUGIN pluginId="${pluginRefId}">>\n${skillMarkdown}${inventory}\n<</AGENT_PLUGIN>>`,
+        };
+    }
+    function buildPointerSection(pluginRefId, plugin) {
+        if (!plugin.skills.some((skill) => skill.name === pluginRefId)) {
+            return {
+                ok: false,
+                reason: `Agent Plugin '${pluginRefId}' has no readable 'skills/${pluginRefId}/SKILL.md' in its installed package: no such skill folder`,
+            };
+        }
+        const body = ports.formatPluginToolPointer({ pluginId: pluginRefId });
+        return { ok: true, section: `<<AGENT_PLUGIN pluginId="${pluginRefId}">>\n${body}\n<</AGENT_PLUGIN>>` };
+    }
+    return { resolveAgentPluginRefs, listInstalledPlugins, isInstalledDigestPresent };
+}
+const instances = new WeakMap();
+/** Internal composition; one state/queue instance per injected host context. */
+export function createResolveAgentPluginRefsModule(ports) {
+    let instance = instances.get(ports);
+    if (!instance) {
+        instance = buildModule(ports);
+        instances.set(ports, instance);
+    }
+    return instance;
+}
+//# sourceMappingURL=resolve-agent-plugin-refs.js.map

package/dist/lifecycle/retire-bundled.d.ts

@@ -0,0 +1,36 @@
+/** Extracted from the host plugin lifecycle. Effects are supplied per host context. */
+import { type BundledAgentPluginEnableOutcome } from "./activation.js";
+import type { AgentPluginLayout } from "./layout.js";
+import type { AgentPluginLifecyclePorts } from "./ports.js";
+export type RetiredAgentPluginSuccessorOutcome = BundledAgentPluginEnableOutcome | "not-needed";
+export type RetiredAgentPluginOutcome = {
+    readonly pluginId: string;
+    readonly successorId: string;
+    readonly status: "absent";
+} | {
+    readonly pluginId: string;
+    readonly successorId: string;
+    readonly status: "retired";
+    readonly removedDigests: readonly string[];
+    readonly activationRemoved: boolean;
+    readonly ledgerEntryRemoved: boolean;
+    readonly successor: RetiredAgentPluginSuccessorOutcome;
+} | {
+    readonly pluginId: string;
+    readonly successorId: string;
+    readonly status: "failed";
+    readonly reason: string;
+};
+export interface RetireBundledAgentPluginsRequired {
+    readonly layout: AgentPluginLayout;
+    readonly workspaceId: string;
+}
+export interface RetireBundledAgentPluginsOptional {
+    readonly retired?: (ReadonlyMap<string, string>) | undefined;
+    readonly now?: ((required: Record<string, never>) => Date) | undefined;
+}
+/** Internal composition; one state/queue instance per injected host context. */
+export declare function createRetireBundledModule(ports: AgentPluginLifecyclePorts): {
+    retireBundledAgentPlugins: (required: RetireBundledAgentPluginsRequired, optional?: RetireBundledAgentPluginsOptional) => Promise<readonly RetiredAgentPluginOutcome[]>;
+};
+//# sourceMappingURL=retire-bundled.d.ts.map

package/dist/lifecycle/retire-bundled.js

@@ -0,0 +1,69 @@
+/** Extracted from the host plugin lifecycle. Effects are supplied per host context. */
+import {} from "./activation.js";
+import { createActivationModule } from "./activation.js";
+import { createBundledDigestsModule } from "./bundled-digests.js";
+import { createResolveAgentPluginRefsModule } from "./resolve-agent-plugin-refs.js";
+import { createUninstallModule } from "./uninstall.js";
+function buildModule(ports) {
+    const { deleteAgentPluginActivation, enableBundledAgentPluginUnlessOperatorDisabled, readAgentPluginActivations, resolveAgentPluginActivation } = createActivationModule(ports);
+    const { removeBundledAgentPluginDigest } = createBundledDigestsModule(ports);
+    const { listInstalledPlugins } = createResolveAgentPluginRefsModule(ports);
+    const { uninstallAgentPlugin } = createUninstallModule(ports);
+    async function retireBundledAgentPlugins(required, optional = {}) {
+        const outcomes = [];
+        for (const [pluginId, successorId] of optional.retired ?? ports.retiredBundledPlugins) {
+            try {
+                outcomes.push(await retireOne(required, optional, pluginId, successorId));
+            }
+            catch (error) {
+                outcomes.push({ pluginId, successorId, status: "failed", reason: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        return outcomes;
+    }
+    async function retireOne(required, optional, pluginId, successorId) {
+        const workspaceLayout = required.layout.forWorkspace({ workspaceId: required.workspaceId });
+        const workspaceRoot = workspaceLayout.root;
+        const verdict = await resolveAgentPluginActivation(workspaceRoot, pluginId);
+        if (verdict.verdict === "undetermined") {
+            return { pluginId, successorId, status: "failed", reason: `cannot tell whether '${pluginId}' was enabled: ${verdict.reason}` };
+        }
+        const installed = (await listInstalledPlugins(workspaceLayout.packages)).filter((plugin) => plugin.pluginId === pluginId);
+        const hasRecord = Object.hasOwn((await readAgentPluginActivations(workspaceRoot)).plugins, pluginId);
+        if (installed.length === 0 && !hasRecord) {
+            const ledgerEntryRemoved = await removeBundledAgentPluginDigest({ workspaceRoot, pluginId });
+            if (!ledgerEntryRemoved)
+                return { pluginId, successorId, status: "absent" };
+            return { pluginId, successorId, status: "retired", removedDigests: [], activationRemoved: false, ledgerEntryRemoved, successor: "not-needed" };
+        }
+        const successor = verdict.verdict === "active"
+            ? await enableBundledAgentPluginUnlessOperatorDisabled({
+                workspaceRoot,
+                pluginId: successorId,
+                actor: `system:retire-${pluginId}`,
+                ...(optional.now !== undefined ? { now: optional.now } : {}),
+            })
+            : "not-needed";
+        let removedDigests = [];
+        if (installed.length > 0) {
+            removedDigests = (await uninstallAgentPlugin({ layout: required.layout, workspaceId: required.workspaceId, pluginId }, { retiredBundled: true })).removedDigests;
+        }
+        else {
+            await deleteAgentPluginActivation({ workspaceRoot, pluginId });
+        }
+        const ledgerEntryRemoved = await removeBundledAgentPluginDigest({ workspaceRoot, pluginId });
+        return { pluginId, successorId, status: "retired", removedDigests, activationRemoved: hasRecord, ledgerEntryRemoved, successor };
+    }
+    return { retireBundledAgentPlugins };
+}
+const instances = new WeakMap();
+/** Internal composition; one state/queue instance per injected host context. */
+export function createRetireBundledModule(ports) {
+    let instance = instances.get(ports);
+    if (!instance) {
+        instance = buildModule(ports);
+        instances.set(ports, instance);
+    }
+    return instance;
+}
+//# sourceMappingURL=retire-bundled.js.map

package/dist/lifecycle/search.d.ts

@@ -0,0 +1,23 @@
+/** Extracted from the host plugin lifecycle. Effects are supplied per host context. */
+import type { AgentPluginLifecyclePorts } from "./ports.js";
+export interface AgentPluginSearchSkill {
+    readonly name: string;
+    readonly summary: string;
+}
+export interface AgentPluginSearchCandidate {
+    readonly pluginId: string;
+    readonly version?: (string) | undefined;
+    readonly description?: (string) | undefined;
+    readonly keywords: readonly string[];
+    readonly enabled: boolean;
+    readonly skills: readonly AgentPluginSearchSkill[];
+    readonly mcpServerIds: readonly string[];
+}
+export interface AgentPluginSearchMatch extends AgentPluginSearchCandidate {
+    readonly score: number;
+}
+/** Internal composition; one state/queue instance per injected host context. */
+export declare function createSearchModule(ports: AgentPluginLifecyclePorts): {
+    rankInstalledAgentPlugins: (query: string, candidates: readonly AgentPluginSearchCandidate[], limit: number) => readonly AgentPluginSearchMatch[];
+};
+//# sourceMappingURL=search.d.ts.map

package/dist/lifecycle/search.js

@@ -0,0 +1,50 @@
+/** Extracted from the host plugin lifecycle. Effects are supplied per host context. */
+function buildModule(ports) {
+    const ID_FIELD_WEIGHT = 5;
+    const KEYWORD_FIELD_WEIGHT = 4;
+    const DESCRIPTION_FIELD_WEIGHT = 2;
+    const SKILL_FIELD_WEIGHT = 1;
+    function tokenize(query) {
+        return query
+            .toLowerCase()
+            .split(/\s+/)
+            .filter((term) => term.length > 0);
+    }
+    function fieldHaystacks(candidate) {
+        return [
+            { text: candidate.pluginId.toLowerCase(), weight: ID_FIELD_WEIGHT },
+            { text: candidate.keywords.join(" ").toLowerCase(), weight: KEYWORD_FIELD_WEIGHT },
+            { text: (candidate.description ?? "").toLowerCase(), weight: DESCRIPTION_FIELD_WEIGHT },
+            {
+                text: candidate.skills.map((skill) => `${skill.name} ${skill.summary}`).join(" ").toLowerCase(),
+                weight: SKILL_FIELD_WEIGHT,
+            },
+        ];
+    }
+    function scoreCandidate(candidate, terms) {
+        const haystacks = fieldHaystacks(candidate);
+        return terms.reduce((total, term) => total + haystacks.reduce((fieldTotal, haystack) => (haystack.text.includes(term) ? fieldTotal + haystack.weight : fieldTotal), 0), 0);
+    }
+    function rankInstalledAgentPlugins(query, candidates, limit) {
+        const terms = tokenize(query);
+        if (terms.length === 0)
+            return [];
+        return candidates
+            .map((candidate) => ({ ...candidate, score: scoreCandidate(candidate, terms) }))
+            .filter((match) => match.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, Math.max(limit, 0));
+    }
+    return { rankInstalledAgentPlugins };
+}
+const instances = new WeakMap();
+/** Internal composition; one state/queue instance per injected host context. */
+export function createSearchModule(ports) {
+    let instance = instances.get(ports);
+    if (!instance) {
+        instance = buildModule(ports);
+        instances.set(ports, instance);
+    }
+    return instance;
+}
+//# sourceMappingURL=search.js.map

package/dist/lifecycle/seed-bundled.d.ts

@@ -0,0 +1,29 @@
+import type { AgentPluginLayout } from "./layout.js";
+import { type RetiredAgentPluginOutcome } from "./retire-bundled.js";
+import type { AgentPluginLifecyclePorts } from "./ports.js";
+export type SeededAgentPluginOutcome = {
+    readonly pluginId: string;
+    readonly status: "seeded";
+    readonly archiveDigest: string;
+    readonly activationRecorded: boolean;
+} | {
+    readonly pluginId: string;
+    readonly status: "failed";
+    readonly reason: string;
+};
+export interface SeedBundledAgentPluginsResult {
+    readonly sourceRoot: string;
+    readonly outcomes: readonly SeededAgentPluginOutcome[];
+    readonly ledgerFailure?: (string) | undefined;
+    readonly retirements: readonly RetiredAgentPluginOutcome[];
+}
+export interface SeedBundledAgentPluginsRequired {
+    readonly layout: AgentPluginLayout;
+    readonly workspaceId: string;
+    readonly sourceRoot: string;
+}
+/** Internal composition; one state/queue instance per injected host context. */
+export declare function createSeedBundledModule(ports: AgentPluginLifecyclePorts): {
+    seedBundledAgentPlugins: (required: SeedBundledAgentPluginsRequired) => Promise<SeedBundledAgentPluginsResult>;
+};
+//# sourceMappingURL=seed-bundled.d.ts.map

package/dist/lifecycle/seed-bundled.js

@@ -0,0 +1,118 @@
+import path from "node:path";
+import { createActivationModule } from "./activation.js";
+import { createBundledDigestsModule } from "./bundled-digests.js";
+import { createBundledSourceArchiveModule } from "./bundled-source-archive.js";
+import { createInstallModule } from "./install.js";
+import {} from "./retire-bundled.js";
+import { createRetireBundledModule } from "./retire-bundled.js";
+function buildModule(ports) {
+    const readdir = ports.filesystem.readdir.bind(ports.filesystem);
+    const stat = ports.filesystem.stat.bind(ports.filesystem);
+    const { assertAgentPluginActivationsWritable, recordBundledAgentPluginIfAbsent } = createActivationModule(ports);
+    const { recordBundledAgentPluginDigests } = createBundledDigestsModule(ports);
+    const { createBundledSourceArchiveReader, packAgentPluginDirectory } = createBundledSourceArchiveModule(ports);
+    const { installAgentPlugin } = createInstallModule(ports);
+    const { retireBundledAgentPlugins } = createRetireBundledModule(ports);
+    async function seedBundledAgentPlugins(required) {
+        const { layout, workspaceId, sourceRoot } = required;
+        const pluginDirNames = await listBundledPluginDirs(sourceRoot);
+        const refusal = await activationsRefusal(layout, workspaceId);
+        if (refusal !== undefined) {
+            return {
+                sourceRoot,
+                outcomes: pluginDirNames.map((dirName) => ({ pluginId: dirName, status: "failed", reason: refusal })),
+                retirements: [],
+            };
+        }
+        const outcomes = [];
+        for (const dirName of pluginDirNames) {
+            outcomes.push(await seedOne({ layout, workspaceId, sourceDir: path.join(sourceRoot, dirName), dirName }));
+        }
+        const ledgerFailure = await recordSeededDigests(layout.forWorkspace({ workspaceId }).root, outcomes);
+        const retirements = await retireBundledAgentPlugins({ layout, workspaceId });
+        return { sourceRoot, outcomes, retirements, ...(ledgerFailure !== undefined ? { ledgerFailure } : {}) };
+    }
+    async function recordSeededDigests(workspaceRoot, outcomes) {
+        try {
+            await recordBundledAgentPluginDigests({
+                workspaceRoot,
+                seeded: outcomes.flatMap((outcome) => outcome.status === "seeded" ? [{ pluginId: outcome.pluginId, archiveDigest: outcome.archiveDigest }] : []),
+            });
+            return undefined;
+        }
+        catch (error) {
+            return error instanceof Error ? error.message : String(error);
+        }
+    }
+    async function activationsRefusal(layout, workspaceId) {
+        try {
+            await assertAgentPluginActivationsWritable(layout.forWorkspace({ workspaceId }).root);
+            return undefined;
+        }
+        catch (error) {
+            return error instanceof Error ? error.message : String(error);
+        }
+    }
+    async function seedOne(args) {
+        try {
+            const packed = await packAgentPluginDirectory(args.sourceDir);
+            const installed = await installAgentPlugin({
+                archive: packed.bytes,
+                expectedSha256: packed.sha256,
+                archiveReader: createBundledSourceArchiveReader(),
+                layout: args.layout,
+                workspaceId: args.workspaceId,
+            });
+            const { recorded } = await recordBundledAgentPluginIfAbsent({ workspaceRoot: args.layout.forWorkspace({ workspaceId: args.workspaceId }).root, pluginId: installed.pluginId }, { enabled: ports.seededEnabledPluginIds.has(installed.pluginId) });
+            return {
+                pluginId: installed.pluginId,
+                status: "seeded",
+                archiveDigest: installed.archiveDigest,
+                activationRecorded: recorded,
+            };
+        }
+        catch (error) {
+            return {
+                pluginId: args.dirName,
+                status: "failed",
+                reason: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async function listBundledPluginDirs(sourceRoot) {
+        let entries;
+        try {
+            entries = await readdir(sourceRoot, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+        const dirs = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (ports.retiredBundledPlugins.has(entry.name))
+                continue;
+            try {
+                const manifest = await stat(path.join(sourceRoot, entry.name, "plugin.json"));
+                if (manifest.isFile())
+                    dirs.push(entry.name);
+            }
+            catch {
+            }
+        }
+        return dirs.sort();
+    }
+    return { seedBundledAgentPlugins };
+}
+const instances = new WeakMap();
+/** Internal composition; one state/queue instance per injected host context. */
+export function createSeedBundledModule(ports) {
+    let instance = instances.get(ports);
+    if (!instance) {
+        instance = buildModule(ports);
+        instances.set(ports, instance);
+    }
+    return instance;
+}
+//# sourceMappingURL=seed-bundled.js.map

package/dist/lifecycle/set-enabled.d.ts

@@ -0,0 +1,21 @@
+import type { AgentPluginLifecyclePorts } from "./ports.js";
+export declare class AgentPluginNotInstalledError extends Error {
+    constructor({ pluginId }: {
+        readonly pluginId: string;
+    });
+}
+export interface SetAgentPluginEnabledInput {
+    readonly workspaceId: string;
+    readonly pluginId: string;
+    readonly enabled: boolean;
+    readonly actor: string;
+}
+export interface SetAgentPluginEnabledResult {
+    readonly pluginId: string;
+    readonly enabled: boolean;
+}
+/** Internal composition; one state/queue instance per injected host context. */
+export declare function createSetEnabledModule(ports: AgentPluginLifecyclePorts): {
+    setAgentPluginEnabled: (input: SetAgentPluginEnabledInput) => Promise<SetAgentPluginEnabledResult>;
+};
+//# sourceMappingURL=set-enabled.d.ts.map

package/dist/lifecycle/set-enabled.js

@@ -0,0 +1,39 @@
+/** Extracted from the host plugin lifecycle. Effects are supplied per host context. */
+import { createActivationModule } from "./activation.js";
+import { createResolveAgentPluginRefsModule } from "./resolve-agent-plugin-refs.js";
+export class AgentPluginNotInstalledError extends Error {
+    constructor({ pluginId }) {
+        super(`agent plugin '${pluginId}' is not installed in this workspace`);
+        this.name = "AgentPluginNotInstalledError";
+    }
+}
+function buildModule(ports) {
+    const { setAgentPluginActivation } = createActivationModule(ports);
+    const { listInstalledPlugins } = createResolveAgentPluginRefsModule(ports);
+    async function setAgentPluginEnabled(input) {
+        const workspaceLayout = ports.layout.forWorkspace({ workspaceId: input.workspaceId });
+        const installed = await listInstalledPlugins(workspaceLayout.packages);
+        if (!installed.some((plugin) => plugin.pluginId === input.pluginId)) {
+            throw new AgentPluginNotInstalledError({ pluginId: input.pluginId });
+        }
+        const written = await setAgentPluginActivation({
+            workspaceRoot: workspaceLayout.root,
+            pluginId: input.pluginId,
+            enabled: input.enabled,
+            actor: input.actor,
+        });
+        return { pluginId: input.pluginId, enabled: written.plugins[input.pluginId]?.enabled ?? input.enabled };
+    }
+    return { setAgentPluginEnabled };
+}
+const instances = new WeakMap();
+/** Internal composition; one state/queue instance per injected host context. */
+export function createSetEnabledModule(ports) {
+    let instance = instances.get(ports);
+    if (!instance) {
+        instance = buildModule(ports);
+        instances.set(ports, instance);
+    }
+    return instance;
+}
+//# sourceMappingURL=set-enabled.js.map

package/dist/lifecycle/trusted-plugin-files.d.ts

@@ -0,0 +1,29 @@
+import type { AgentPluginLifecyclePorts } from "./ports.js";
+export interface TrustedPluginPackage {
+    readonly pluginId: string;
+    readonly packageRoot: string;
+}
+export interface TrustedPluginPackagesQuery {
+    readonly workspaceId: string;
+    readonly filename: string;
+    readonly contribution: string;
+    readonly requireActive: boolean;
+    readonly orderByPluginId?: (boolean) | undefined;
+    readonly onInactive?: ((required: {
+        readonly plugin: TrustedPluginPackage;
+    }) => Promise<void>) | undefined;
+}
+export type TrustedPluginVerdict = {
+    readonly trusted: TrustedPluginPackage;
+} | {
+    readonly refusal: string;
+};
+/** Internal composition; one state/queue instance per injected host context. */
+export declare function createTrustedPluginFilesModule(ports: AgentPluginLifecyclePorts): {
+    findTrustedPluginPackages: (query: TrustedPluginPackagesQuery) => Promise<readonly TrustedPluginVerdict[]>;
+    readTrustedPluginFile: (plugin: TrustedPluginPackage, filename: string) => Promise<string>;
+    importContainedModule: (plugin: TrustedPluginPackage, modulePath: string) => Promise<{
+        readonly exported: unknown;
+    } | string>;
+};
+//# sourceMappingURL=trusted-plugin-files.d.ts.map

package/dist/lifecycle/trusted-plugin-files.js

@@ -0,0 +1,82 @@
+/** Extracted from the host plugin lifecycle. Effects are supplied per host context. */
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { createActivationModule } from "./activation.js";
+import { createBundledDigestsModule } from "./bundled-digests.js";
+import { PackagePathViolation } from "./package-paths.js";
+import { createPackagePathsModule } from "./package-paths.js";
+import { createResolveAgentPluginRefsModule } from "./resolve-agent-plugin-refs.js";
+function buildModule(ports) {
+    const readFile = ports.filesystem.readFile.bind(ports.filesystem);
+    const { resolveAgentPluginActivation } = createActivationModule(ports);
+    const { preferBundledAgentPluginDigests, readBundledAgentPluginDigests } = createBundledDigestsModule(ports);
+    const { assertContainedOnDisk } = createPackagePathsModule(ports);
+    const { listInstalledPlugins } = createResolveAgentPluginRefsModule(ports);
+    async function findTrustedPluginPackages(query) {
+        const layout = ports.layout.forWorkspace({ workspaceId: query.workspaceId });
+        const bundled = await readBundledAgentPluginDigests(layout.root);
+        const preferred = preferBundledAgentPluginDigests(await listInstalledPlugins(layout.packages), bundled);
+        const installed = query.orderByPluginId ? [...preferred].sort((a, b) => a.pluginId.localeCompare(b.pluginId)) : preferred;
+        const verdicts = [];
+        for (const plugin of installed) {
+            if (!plugin.files.includes(query.filename))
+                continue;
+            const refusal = await trustRefusal(query, plugin, bundled.get(plugin.pluginId), layout.root);
+            const trusted = { pluginId: plugin.pluginId, packageRoot: plugin.packageRoot };
+            if (refusal === null)
+                verdicts.push({ trusted });
+            else if (refusal === "inactive")
+                await query.onInactive?.({ plugin: trusted });
+            else
+                verdicts.push({ refusal: `${query.contribution} from '${plugin.pluginId}' were not loaded: ${refusal}` });
+        }
+        return verdicts;
+    }
+    async function trustRefusal(query, plugin, bundledDigest, workspaceRoot) {
+        if (query.requireActive) {
+            const activation = await resolveAgentPluginActivation(workspaceRoot, plugin.pluginId);
+            if (activation.verdict === "inactive")
+                return "inactive";
+            if (activation.verdict === "undetermined")
+                return `its activation could not be read (${activation.reason})`;
+        }
+        if (bundledDigest !== plugin.archiveDigest) {
+            return `only plugins shipped with ${ports.productName} may add ${query.contribution} (installed digest ${plugin.archiveDigest.slice(0, 12)} is not the one this build shipped)`;
+        }
+        return null;
+    }
+    async function readTrustedPluginFile(plugin, filename) {
+        const absolute = await assertContainedOnDisk(plugin.packageRoot, filename);
+        return readFile(absolute, "utf8");
+    }
+    async function importContainedModule(plugin, modulePath) {
+        let resolved;
+        try {
+            resolved = await assertContainedOnDisk(plugin.packageRoot, modulePath);
+        }
+        catch (error) {
+            if (error instanceof PackagePathViolation)
+                return `module path '${modulePath}' escapes the plugin root`;
+            throw error;
+        }
+        try {
+            const imported = (await import(pathToFileURL(resolved).href));
+            return { exported: imported.default };
+        }
+        catch (error) {
+            return error instanceof Error ? error.message : String(error);
+        }
+    }
+    return { findTrustedPluginPackages, readTrustedPluginFile, importContainedModule };
+}
+const instances = new WeakMap();
+/** Internal composition; one state/queue instance per injected host context. */
+export function createTrustedPluginFilesModule(ports) {
+    let instance = instances.get(ports);
+    if (!instance) {
+        instance = buildModule(ports);
+        instances.set(ports, instance);
+    }
+    return instance;
+}
+//# sourceMappingURL=trusted-plugin-files.js.map