@jini-ai/admin 0.4.11 → 0.4.13

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.4.13 — 2026-10-22
+
+- 2026-10-22: Consent banner editor sections and preview, redirect list fixes, media lightbox via @jini-ai/ui, media provider tab fixes, coverage.
+
+## 0.4.12 — 2026-10-16
+
+- SEO: searchable entry picker and grouped per-entry form (6c128f9d); image fields name the file, styled analysis, slug for same-titled entries (bc1dbf0d); one Social preview section with an optional "Customize for X" (ff1a709f); X/Twitter labels, file names with extensions, muted inherited site-default image (4919371d); "Using image from page content" when the share image comes from the page (746457d9).
+- Peers: `@jini-ai/ui` `^0.5.5` (grouped Select) and `@jini-ai/cms` `^0.5.13` (share-image source).
+
 ## 0.4.11 — 2026-10-14
 
 - `FieldAttributesDialog` and `SitemapModal` use the neutral `jini-domain-dialog` class instead of a host-named one; hosts style `.jini-domain-dialog` (47b9fa4f).

package/dist/agent-plugins/controllers/agent-plugin-files.controller.js

@@ -1,14 +1,22 @@
 import { createControllerStore } from '../../core/module/controller-store.js';
 import { agentPluginFilesSnapshot, selectAgentPluginFile, AGENT_PLUGINS_READ } from '../rules.js';
 import { agentPluginsMessagesEn as m } from '../messages.en.js';
+const selectedPathIn = ({ files, path }, _optional = {}) => selectAgentPluginFile({ files, path })?.relativePath ?? '';
 export function createAgentPluginFilesController({ api, permissions = [] }, _optional = {}) {
     const store = createControllerStore({ initial: { pluginId: null, listing: null, loading: false, error: null, selectedPath: '' } });
     let generation = 0, pending = null;
     function cancel() { generation++; pending?.abort(); pending = null; }
+    const canRead = () => !store.signal.aborted && permissions.includes(AGENT_PLUGINS_READ);
+    function accept({ pluginId, result }, _optional = {}) {
+        if (result.pluginId !== pluginId)
+            throw new Error(`Files response was for plugin "${result.pluginId}", expected "${pluginId}"`);
+        const listing = agentPluginFilesSnapshot({ listing: result });
+        store.set({ patch: { listing, selectedPath: selectedPathIn({ files: listing.files, path: '' }) } });
+    }
     return {
         getSnapshot: store.getSnapshot, subscribe: store.subscribe,
         async open({ pluginId }, _optional = {}) {
-            if (store.signal.aborted || !permissions.includes(AGENT_PLUGINS_READ))
+            if (!canRead())
                 return;
             cancel();
             const ticket = generation, abort = new AbortController();
@@ -16,12 +24,9 @@ export function createAgentPluginFilesController({ api, permissions = [] }, _opt
             store.set({ patch: { pluginId, listing: null, loading: true, error: null, selectedPath: '' } });
             try {
                 const result = await api.files({ pluginId }, { signal: abort.signal });
-                if (ticket !== generation || store.signal.aborted)
-                    return;
-                if (result.pluginId !== pluginId)
-                    throw new Error('Invalid files response');
-                const listing = agentPluginFilesSnapshot({ listing: result });
-                store.set({ patch: { listing, selectedPath: selectAgentPluginFile({ files: listing.files, path: '' })?.relativePath ?? '' } });
+                // Disposal cancels first (bumping generation), so a stale ticket also covers a disposed store.
+                if (ticket === generation)
+                    accept({ pluginId, result });
             }
             catch {
                 if (ticket === generation)
@@ -34,8 +39,8 @@ export function createAgentPluginFilesController({ api, permissions = [] }, _opt
                 }
             }
         },
-        select({ path }, _optional = {}) { if (store.signal.aborted)
-            return; store.set({ patch: { selectedPath: selectAgentPluginFile({ files: store.getSnapshot().listing?.files ?? [], path })?.relativePath ?? '' } }); },
+        // A disposed store already ignores writes, so no separate disposed check is needed here.
+        select({ path }, _optional = {}) { store.set({ patch: { selectedPath: selectedPathIn({ files: store.getSnapshot().listing?.files ?? [], path }) } }); },
         close(_required, _optional = {}) { cancel(); store.set({ patch: { pluginId: null, listing: null, loading: false, error: null, selectedPath: '' } }); },
         dispose(_required = {}, _optional = {}) { cancel(); store.set({ patch: { pluginId: null, listing: null, selectedPath: '' } }); store.dispose(); },
     };

package/dist/agent-plugins/controllers/agent-plugins.controller.js

@@ -8,6 +8,12 @@ export function createAgentPluginsController({ api, permissions = [] }, _optiona
     const canRead = () => !store.signal.aborted && grants.has(AGENT_PLUGINS_READ);
     const canWrite = () => canRead() && grants.has(AGENT_PLUGINS_WRITE);
     const rowFor = (id) => store.getSnapshot().plugins?.find(p => p.pluginId === id);
+    function acceptList({ plugins }, _optional = {}) {
+        const rows = Object.freeze(plugins.map(row => agentPluginSummary({ row })));
+        const state = store.getSnapshot(), listed = (id) => rows.some(p => p.pluginId === id);
+        const pendingStillEnabled = rows.some(p => p.pluginId === state.pendingDisable?.pluginId && p.enabled);
+        store.set({ patch: { plugins: rows, inspectedId: listed(state.inspectedId) ? state.inspectedId : null, pendingDisable: pendingStillEnabled ? state.pendingDisable : null, expandedIds: state.expandedIds.filter(id => listed(id)) } });
+    }
     async function load(_required, _optional = {}) {
         if (!canRead())
             return;
@@ -16,13 +22,9 @@ export function createAgentPluginsController({ api, permissions = [] }, _optiona
         try {
             const plugins = await api.list({}, { signal: store.signal });
             // Older reads cannot overwrite accepted writes; each updated row replaces itself once.
-            if (ticket !== generation || store.signal.aborted)
-                return;
-            if (version === revision) {
-                const rows = Object.freeze(plugins.map(row => agentPluginSummary({ row })));
-                const state = store.getSnapshot();
-                store.set({ patch: { plugins: rows, inspectedId: rows.some(p => p.pluginId === state.inspectedId) ? state.inspectedId : null, pendingDisable: rows.some(p => p.pluginId === state.pendingDisable?.pluginId && p.enabled) ? state.pendingDisable : null, expandedIds: state.expandedIds.filter(id => rows.some(p => p.pluginId === id)) } });
-            }
+            // Disposal bumps generation, so a current ticket also means the store is not disposed.
+            if (ticket === generation && version === revision)
+                acceptList({ plugins });
         }
         catch {
             if (ticket === generation)
@@ -46,17 +48,18 @@ export function createAgentPluginsController({ api, permissions = [] }, _optiona
                 throw new Error('Invalid activation response');
             revision++;
             // No optimistic flip: independent rows always splice into the newest snapshot.
+            // rowFor found this row above and plugins is never reset to null, so the list exists here.
             const current = store.getSnapshot();
-            store.set({ patch: { plugins: Object.freeze((current.plugins ?? []).map(p => p.pluginId === updated.pluginId ? agentPluginSummary({ row: updated }) : p)) } });
+            store.set({ patch: { plugins: Object.freeze(current.plugins.map(p => p.pluginId === updated.pluginId ? agentPluginSummary({ row: updated }) : p)) } });
             return true;
         }
         catch {
             store.set({ patch: { actionError: m.actionError } });
-            return false;
         }
         finally {
             store.set({ patch: { busyIds: store.getSnapshot().busyIds.filter(id => id !== input.pluginId) } });
         }
+        return false;
     }
     return {
         getSnapshot: store.getSnapshot, subscribe: store.subscribe, load, setEnabled,

package/dist/agent-plugins/package-file-tree.js

@@ -8,20 +8,16 @@
  */
 const collator = new Intl.Collator("en", { numeric: true, sensitivity: "base" });
 /** Files first, then folders, each alphabetical (owner's call, 2026-09-29 — VS Code's default is the reverse). */
-function compareNodes(a, b, sorter = collator) {
-    if (a.kind !== b.kind)
-        return a.kind === "file" ? -1 : 1;
-    return sorter.compare(a.name, b.name) || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
-}
-function freeze(folder, prefix, sorter = collator) {
-    const nodes = [];
-    for (const [name, child] of folder.folders) {
+function freeze(folder, prefix, sorter) {
+    // Two same-kind siblings never share a name (folders are keyed by name, files deduped by path),
+    // so a collator tie only needs a code-unit tie-break, never an "equal" result.
+    const byName = (a, b) => sorter.compare(a.name, b.name) || (a.name < b.name ? -1 : 1);
+    const files = folder.files.map((file) => ({ kind: "file", ...file })).sort(byName);
+    const folders = [...folder.folders].map(([name, child]) => {
         const path = prefix ? `${prefix}/${name}` : name;
-        nodes.push({ kind: "folder", name, path, children: freeze(child, path, sorter) });
-    }
-    for (const file of folder.files)
-        nodes.push({ kind: "file", ...file });
-    return nodes.sort((a, b) => compareNodes(a, b, sorter));
+        return { kind: "folder", name, path, children: freeze(child, path, sorter) };
+    }).sort(byName);
+    return [...files, ...folders];
 }
 /**
  * Groups flat package-relative paths into a folder tree. Empty segments (a leading, trailing or
@@ -38,15 +34,7 @@ export function buildPackageFileTree({ paths }, optional = {}) {
         const fileName = segments.pop();
         if (!fileName)
             continue;
-        let folder = root;
-        for (const segment of segments) {
-            let next = folder.folders.get(segment);
-            if (!next) {
-                next = { folders: new Map(), files: [] };
-                folder.folders.set(segment, next);
-            }
-            folder = next;
-        }
+        const folder = folderAt({ root, segments });
         const normalized = [...segments, fileName].join("/");
         if (seen.has(normalized))
             continue;
@@ -55,6 +43,19 @@ export function buildPackageFileTree({ paths }, optional = {}) {
     }
     return freeze(root, "", optional.locale === undefined ? collator : new Intl.Collator(optional.locale, { numeric: true, sensitivity: "base" }));
 }
+/** Walks `segments` down from `root`, creating each missing folder on the way. */
+function folderAt({ root, segments }, _optional = {}) {
+    let folder = root;
+    for (const segment of segments) {
+        let next = folder.folders.get(segment);
+        if (!next) {
+            next = { folders: new Map(), files: [] };
+            folder.folders.set(segment, next);
+        }
+        folder = next;
+    }
+    return folder;
+}
 /**
  * The path of the tree's top file row once every folder on the way is open — the first file in
  * display order (files before folders, so a root file wins over anything nested); `null` for no files.
@@ -109,36 +110,38 @@ export function packageFileTreeKeyAction({ rows, currentPath, key, isExpanded },
         return {};
     const index = Math.max(0, rows.findIndex((row) => row.node.path === currentPath));
     const row = rows[index];
-    const node = row.node;
-    const open = node.kind === "folder" && isExpanded({ path: node.path });
-    switch (key) {
-        case "ArrowDown":
-            return { focus: rows[Math.min(index + 1, rows.length - 1)].node.path };
-        case "ArrowUp":
-            return { focus: rows[Math.max(index - 1, 0)].node.path };
-        case "Home":
-            return { focus: rows[0].node.path };
-        case "End":
-            return { focus: rows[rows.length - 1].node.path };
-        case "ArrowRight":
-            if (node.kind !== "folder")
-                return { focus: node.path };
-            if (!open)
-                return { focus: node.path, setExpanded: { path: node.path, expanded: true } };
-            return { focus: rows[index + 1]?.parentPath === node.path ? rows[index + 1].node.path : node.path };
-        case "ArrowLeft":
-            if (open)
-                return { focus: node.path, setExpanded: { path: node.path, expanded: false } };
-            return { focus: row.parentPath ?? node.path };
-        case "Enter":
-        case " ":
-            if (node.kind === "file")
-                return { focus: node.path, open: node.path };
-            return { focus: node.path, setExpanded: { path: node.path, expanded: !open } };
-        default:
-            return {};
-    }
+    const open = row.node.kind === "folder" && isExpanded({ path: row.node.path });
+    // A Map, not an object literal, so a key like "constructor" can never resolve to a prototype member.
+    return KEY_HANDLERS.get(key)?.({ rows, index, row, open }) ?? {};
+}
+const focusAt = (rows, index) => ({ focus: rows[index].node.path });
+function arrowRight({ rows, index, row: { node }, open }, _optional = {}) {
+    if (node.kind !== "folder")
+        return { focus: node.path };
+    if (!open)
+        return { focus: node.path, setExpanded: { path: node.path, expanded: true } };
+    return { focus: rows[index + 1]?.parentPath === node.path ? rows[index + 1].node.path : node.path };
+}
+function arrowLeft({ row, open }, _optional = {}) {
+    if (open)
+        return { focus: row.node.path, setExpanded: { path: row.node.path, expanded: false } };
+    return { focus: row.parentPath ?? row.node.path };
+}
+function activate({ row: { node }, open }, _optional = {}) {
+    if (node.kind === "file")
+        return { focus: node.path, open: node.path };
+    return { focus: node.path, setExpanded: { path: node.path, expanded: !open } };
 }
+const KEY_HANDLERS = new Map([
+    ["ArrowDown", ({ rows, index }) => focusAt(rows, Math.min(index + 1, rows.length - 1))],
+    ["ArrowUp", ({ rows, index }) => focusAt(rows, Math.max(index - 1, 0))],
+    ["Home", ({ rows }) => focusAt(rows, 0)],
+    ["End", ({ rows }) => focusAt(rows, rows.length - 1)],
+    ["ArrowRight", arrowRight],
+    ["ArrowLeft", arrowLeft],
+    ["Enter", activate],
+    [" ", activate],
+]);
 const ICON_KIND_BY_EXTENSION = {
     json: "json",
     jsonc: "json",

package/dist/agent-plugins/react/components/AgentPluginRow.d.ts

@@ -1,5 +1,5 @@
 import type { AgentPluginRowView } from '../hooks/AgentPluginPanel.hooks.js';
 export declare function AgentPluginRow({ row }: {
     row: AgentPluginRowView;
-}, _optional?: {}): import("react").JSX.Element;
+}): import("react").JSX.Element;
 //# sourceMappingURL=AgentPluginRow.d.ts.map

package/dist/agent-plugins/react/components/AgentPluginRow.js

@@ -1,8 +1,15 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Badge, Button, IconButton, Switch } from '@jini-ai/ui-kit/react';
 import { useAgentPluginRow } from '../hooks/AgentPluginRow.hooks.js';
-export function AgentPluginRow({ row }, _optional = {}) {
+export function AgentPluginRow({ row }) {
     const vm = useAgentPluginRow({ row });
-    return _jsxs("li", { "data-jini-part": "agent-plugins.row", children: [_jsx("span", { "aria-hidden": true, children: vm.glyph }), _jsxs("h3", { children: [vm.name, " ", vm.version && _jsx("small", { children: vm.version })] }), vm.description && _jsx("p", { children: vm.description }), _jsx(Badge, { children: vm.stateLabel }), vm.installed ? _jsx(Switch, { label: vm.toggleLabel, checked: vm.enabled, disabled: !vm.canWrite || vm.busy, onCheckedChange: vm.toggle }) : _jsx(Button, { attrs: vm.actionAttrs, disabled: !vm.canWrite || vm.busy, pending: vm.busy, onPress: vm.act, children: vm.actionText }), _jsx(Button, { attrs: vm.expandAttrs, onPress: vm.expand, children: "Details" }), _jsx(IconButton, { label: vm.inspectLabel, attrs: vm.inspectAttrs, onPress: vm.inspect, children: "Inspect" }), _jsx(IconButton, { label: vm.uninstallLabel, attrs: vm.uninstallAttrs, disabled: true, children: "Uninstall" }), _jsxs("div", { id: vm.detailId, hidden: vm.detailHidden, children: [vm.description && _jsx("p", { children: vm.description }), vm.hasSkills && _jsxs("section", { "aria-label": "Portable components", children: [_jsx("h4", { children: "Portable components" }), _jsx("ul", { children: vm.skills.map(skill => _jsxs("li", { children: [_jsx("strong", { children: skill.name }), _jsx("p", { children: skill.summary })] }, skill.name)) })] }), vm.hasServers && _jsxs("section", { "aria-label": "MCP servers", children: [_jsx("h4", { children: "MCP servers" }), _jsx("ul", { children: vm.servers.map(id => _jsx("li", { children: id }, id)) })] }), vm.hasKeywords && _jsxs("section", { "aria-label": "Keywords", children: [_jsx("h4", { children: "Keywords" }), _jsx("ul", { children: vm.keywords.map(word => _jsx("li", { children: word }, word)) })] })] })] });
+    return _jsxs("li", { "data-jini-part": "agent-plugins.row", children: [_jsx("span", { "aria-hidden": true, children: vm.glyph }), _jsxs("h3", { children: [vm.name, " ", vm.version && _jsx("small", { children: vm.version })] }), vm.description && _jsx("p", { children: vm.description }), _jsx(Badge, { children: vm.stateLabel }), _jsx(AgentPluginRowActivation, { vm: vm }), _jsx(Button, { attrs: vm.expandAttrs, onPress: vm.expand, children: "Details" }), _jsx(IconButton, { label: vm.inspectLabel, attrs: vm.inspectAttrs, onPress: vm.inspect, children: "Inspect" }), _jsx(IconButton, { label: vm.uninstallLabel, attrs: vm.uninstallAttrs, disabled: true, children: "Uninstall" }), _jsx(AgentPluginRowDetails, { vm: vm })] });
+}
+function AgentPluginRowActivation({ vm }) {
+    const disabled = !vm.canWrite || vm.busy;
+    return vm.installed ? _jsx(Switch, { label: vm.toggleLabel, checked: vm.enabled, disabled: disabled, onCheckedChange: vm.toggle }) : _jsx(Button, { attrs: vm.actionAttrs, disabled: disabled, pending: vm.busy, onPress: vm.act, children: vm.actionText });
+}
+function AgentPluginRowDetails({ vm }) {
+    return _jsxs("div", { id: vm.detailId, hidden: vm.detailHidden, children: [vm.description && _jsx("p", { children: vm.description }), vm.hasSkills && _jsxs("section", { "aria-label": "Portable components", children: [_jsx("h4", { children: "Portable components" }), _jsx("ul", { children: vm.skills.map(skill => _jsxs("li", { children: [_jsx("strong", { children: skill.name }), _jsx("p", { children: skill.summary })] }, skill.name)) })] }), vm.hasServers && _jsxs("section", { "aria-label": "MCP servers", children: [_jsx("h4", { children: "MCP servers" }), _jsx("ul", { children: vm.servers.map(id => _jsx("li", { children: id }, id)) })] }), vm.hasKeywords && _jsxs("section", { "aria-label": "Keywords", children: [_jsx("h4", { children: "Keywords" }), _jsx("ul", { children: vm.keywords.map(word => _jsx("li", { children: word }, word)) })] })] });
 }
 //# sourceMappingURL=AgentPluginRow.js.map

package/dist/agent-plugins/react/hooks/AgentPluginInspector.hooks.d.ts

@@ -7,8 +7,9 @@ export interface AgentPluginInspectorProps {
     readonly onClose: (required: Record<string, never>, optional?: Record<string, never>) => void;
 }
 export declare function useAgentPluginInspector({ pluginId, permissions, name }: AgentPluginInspectorProps, _optional?: {}): {
-    title: string;
-    denied: boolean;
+    select({ path }: {
+        path: string;
+    }, _optional?: {}): void;
     files: readonly AgentPluginPackageFile[];
     selected: AgentPluginPackageFile | null;
     selectedPath: string | null;
@@ -23,9 +24,8 @@ export declare function useAgentPluginInspector({ pluginId, permissions, name }:
         role: "status";
     } | null;
     listNotice: "Some files are not listed: this package is larger than the viewer’s limits." | null;
-    select({ path }: {
-        path: string;
-    }, _optional?: {}): void;
+    title: string;
+    denied: boolean;
 };
 export declare function useAgentPluginFileTree({ files, selectedPath, onOpen }: {
     files: readonly AgentPluginPackageFile[];

package/dist/agent-plugins/react/hooks/AgentPluginInspector.hooks.js

@@ -9,14 +9,23 @@ export function useAgentPluginInspector({ pluginId, permissions, name }, _option
     const { agentPluginsApi } = useAgentPluginsPorts({}), key = permissions.join('\0');
     const { controller, snapshot } = useController({ create: () => createAgentPluginFilesController({ api: agentPluginsApi, permissions }), dependencies: [agentPluginsApi, key, pluginId] }, { start: ({ controller }) => { void controller.open({ pluginId }); } });
     // Do not show any stored read tagged with another id, even before the new effect commits.
-    const state = snapshot?.pluginId === pluginId ? snapshot : null, files = state?.listing?.files ?? [];
-    const selected = selectAgentPluginFile({ files, path: state?.selectedPath ?? '' });
-    return { title: `${name} — Package files`, denied: !permissions.includes(AGENT_PLUGINS_READ), files, selected, selectedPath: selected?.relativePath ?? null,
-        status: state?.error ? { text: state.error, role: 'alert' } : !state || state.loading ? { text: m.filesLoading, role: 'status' } : !files.length ? { text: m.filesEmpty, role: 'status' } : null,
-        listNotice: state?.listing?.truncated ? m.filesTruncated : null,
+    const state = snapshot?.pluginId === pluginId ? snapshot : null;
+    return { title: `${name} — Package files`, denied: !permissions.includes(AGENT_PLUGINS_READ), ...inspectorFilesView({ state }),
         select({ path }, _optional = {}) { controller?.select({ path }); },
     };
 }
+const filesOf = (state) => state?.listing?.files ?? [];
+function inspectorFilesView({ state }, _optional = {}) {
+    const files = filesOf(state), selected = selectAgentPluginFile({ files, path: state?.selectedPath ?? '' });
+    return { files, selected, selectedPath: selected?.relativePath ?? null, status: inspectorStatus({ state, hasFiles: files.length > 0 }), listNotice: state?.listing?.truncated ? m.filesTruncated : null };
+}
+function inspectorStatus({ state, hasFiles }, _optional = {}) {
+    if (state?.error)
+        return { text: state.error, role: 'alert' };
+    if (!state || state.loading)
+        return { text: m.filesLoading, role: 'status' };
+    return hasFiles ? null : { text: m.filesEmpty, role: 'status' };
+}
 const fileGlyphs = { json: '{}', markdown: 'M↓', javascript: 'JS', typescript: 'TS', config: '⚙', html: '<>', css: '#', image: '▧', shell: '>', text: '¶', file: '▤' };
 export function useAgentPluginFileTree({ files, selectedPath, onOpen }, _optional = {}) {
     const tree = buildPackageFileTree({ paths: files.map(f => f.relativePath) }), [toggled, setToggled] = useState(new Map());

package/dist/agent-plugins/react/hooks/AgentPluginPanel.hooks.d.ts

@@ -1,10 +1,21 @@
 import type { TabViewProps } from '../../../core/react/bind-react.js';
+type PanelMode = 'installed' | 'downloaded';
 export declare function useAgentPluginPanel({ props, mode }: {
     props: TabViewProps;
-    mode: 'installed' | 'downloaded';
+    mode: PanelMode;
 }, _optional?: {}): {
+    uninstallNoteId: string;
+    specUrl: string;
+    reload(_required: Record<string, never>, _optional?: {}): void;
+    lede: "Every plugin installed in this workspace. Only switched-on plugins reach the assistant’s prompt." | "An installed plugin sits inert until you enable it. Enabling one puts its skills in the assistant’s prompt for every run.";
+    label: string;
+    uninstallNotice: string;
+    loading: boolean;
+    error: string | null | undefined;
+    actionError: string | null | undefined;
+    empty: boolean;
     denied: boolean;
-    mode: "installed" | "downloaded";
+    mode: PanelMode;
     rows: {
         id: string;
         name: string;
@@ -15,7 +26,7 @@ export declare function useAgentPluginPanel({ props, mode }: {
         stateLabel: string;
         busy: boolean;
         expanded: boolean;
-        mode: "installed" | "downloaded";
+        mode: PanelMode;
         canWrite: boolean;
         toggleLabel: string;
         actionLabel: string;
@@ -52,16 +63,7 @@ export declare function useAgentPluginPanel({ props, mode }: {
         inspectLabel: string;
         uninstallLabel: string;
     }[];
-    loading: boolean;
-    error: string | null | undefined;
-    actionError: string | null | undefined;
-    empty: boolean;
-    lede: "Every plugin installed in this workspace. Only switched-on plugins reach the assistant’s prompt." | "An installed plugin sits inert until you enable it. Enabling one puts its skills in the assistant’s prompt for every run.";
-    label: string;
-    uninstallNotice: string;
-    uninstallNoteId: string;
-    specUrl: string;
-    reload(_required: Record<string, never>, _optional?: {}): void;
 };
 export type AgentPluginRowView = ReturnType<typeof useAgentPluginPanel>['rows'][number];
+export {};
 //# sourceMappingURL=AgentPluginPanel.hooks.d.ts.map

package/dist/agent-plugins/react/hooks/AgentPluginPanel.hooks.js

@@ -4,48 +4,62 @@ import { useAgentPluginsPageScope } from './AgentPluginsPage.hooks.js';
 const glyphs = { compliance: '◈', deploy: '↗', design: '◇', integration: '⇄', content: '▤', package: '▣' };
 export function useAgentPluginPanel({ props, mode }, _optional = {}) {
     const { controller, snapshot: state, permissions, uninstallNoteId } = useAgentPluginsPageScope({});
-    const canRead = permissions.includes(AGENT_PLUGINS_READ) && !!props.permissions?.includes(AGENT_PLUGINS_READ);
-    const canWrite = canRead && permissions.includes(AGENT_PLUGINS_WRITE) && !!props.permissions?.includes(AGENT_PLUGINS_WRITE);
-    // Scope is intentionally unfiltered on BOTH tabs, including switched-off bundled packages.
-    const busyIds = state?.busyIds ?? [], expandedIds = state?.expandedIds ?? [];
-    const rows = (canRead ? state?.plugins ?? [] : []).map(plugin => {
-        const name = humanizeAgentPluginId({ pluginId: plugin.pluginId }), busy = busyIds.includes(plugin.pluginId);
-        const expanded = expandedIds.includes(plugin.pluginId);
-        // Derived from the id alone, so handles survive sorting and switching tabs.
-        const handle = `agent-plugin-${encodeURIComponent(plugin.pluginId)}`;
-        const turnOff = () => controller?.requestDisable({ pluginId: plugin.pluginId, variant: mode === 'installed' ? 'disable' : 'remove' });
-        return {
-            id: plugin.pluginId, name, version: plugin.version, description: plugin.description,
-            glyph: glyphs[agentPluginGlyphKind({ plugin })], enabled: plugin.enabled, stateLabel: plugin.enabled ? 'Enabled' : 'Disabled',
-            busy, expanded, mode, canWrite, toggleLabel: `${plugin.enabled ? 'Disable' : 'Enable'} ${name}`,
-            actionLabel: `${plugin.enabled ? 'Turn off' : 'Enable'} ${name}`, actionText: plugin.enabled ? 'Turn off' : 'Enable',
-            skills: plugin.skills, keywords: plugin.keywords, servers: plugin.mcpServerIds,
-            hasSkills: plugin.skills.length > 0, hasKeywords: plugin.keywords.length > 0, hasServers: plugin.mcpServerIds.length > 0,
-            toggle(_required, _optional = {}) { if (!canWrite)
-                return; if (plugin.enabled)
-                turnOff();
-            else
-                void controller?.setEnabled({ pluginId: plugin.pluginId, enabled: true }); },
-            act(_required, _optional = {}) { if (!canWrite)
-                return; if (plugin.enabled)
-                turnOff();
-            else
-                void controller?.setEnabled({ pluginId: plugin.pluginId, enabled: true }); },
-            expand(_required, _optional = {}) { controller?.toggleExpanded({ pluginId: plugin.pluginId }); },
-            inspect(_required, _optional = {}) { controller?.inspect({ pluginId: plugin.pluginId }); },
-            expandAttrs: { 'aria-label': `${expanded ? 'Collapse' : 'Expand'} ${name}`, 'aria-expanded': expanded, 'data-agent-handle': `${handle}-expand` },
-            actionAttrs: { 'aria-label': `${plugin.enabled ? 'Turn off' : 'Enable'} ${name}`, 'data-agent-handle': `${handle}-activation` },
-            inspectAttrs: { 'data-agent-handle': `${handle}-inspect` },
-            uninstallAttrs: { 'aria-describedby': uninstallNoteId },
-            inspectLabel: `Inspect ${name} package files`, uninstallLabel: `Uninstall ${name} — unavailable`,
-        };
-    });
-    return { denied: !canRead, mode, rows, loading: !state || (!state.plugins && !state.error), error: state?.error, actionError: state?.actionError, empty: !!state && state.plugins !== null && rows.length === 0,
-        lede: mode === 'installed' ? m.installedLede : m.downloadedLede,
-        label: mode === 'installed' ? 'Installed Agent Plugins' : 'Downloaded Agent Plugins',
-        uninstallNotice: typeof props.params.uninstallNotice === 'string' ? props.params.uninstallNotice : m.uninstallUnavailable,
+    const { canRead, canWrite } = panelGrants({ permissions, granted: props.permissions ?? [] });
+    const rows = panelRows({ state, canRead, controller, mode, canWrite, uninstallNoteId });
+    return { denied: !canRead, mode, rows, ...panelStatus({ state, rowCount: rows.length }),
+        ...panelCopy({ mode, params: props.params }),
         uninstallNoteId, specUrl: AGENT_PLUGINS_SPEC_URL,
         reload(_required, _optional = {}) { void controller?.load({}); },
     };
 }
+/** Both the page scope and the tab's own grants must allow an action. */
+function panelGrants({ permissions, granted }, _optional = {}) {
+    const both = (permission) => permissions.includes(permission) && granted.includes(permission);
+    const canRead = both(AGENT_PLUGINS_READ);
+    return { canRead, canWrite: canRead && both(AGENT_PLUGINS_WRITE) };
+}
+function panelStatus({ state, rowCount }, _optional = {}) {
+    return { loading: !state || (!state.plugins && !state.error), error: state?.error, actionError: state?.actionError, empty: !!state && state.plugins !== null && rowCount === 0 };
+}
+function panelCopy({ mode, params }, _optional = {}) {
+    const installed = mode === 'installed';
+    return { lede: installed ? m.installedLede : m.downloadedLede,
+        label: installed ? 'Installed Agent Plugins' : 'Downloaded Agent Plugins',
+        uninstallNotice: typeof params.uninstallNotice === 'string' ? params.uninstallNotice : m.uninstallUnavailable };
+}
+function panelRows({ state, canRead, ...context }, _optional = {}) {
+    // Scope is intentionally unfiltered on BOTH tabs, including switched-off bundled packages.
+    const busyIds = state?.busyIds ?? [], expandedIds = state?.expandedIds ?? [];
+    return (canRead ? state?.plugins ?? [] : []).map(plugin => agentPluginRowView({ ...context, plugin, busy: busyIds.includes(plugin.pluginId), expanded: expandedIds.includes(plugin.pluginId) }));
+}
+function agentPluginRowView({ plugin, busy, expanded, controller, mode, canWrite, uninstallNoteId }, _optional = {}) {
+    const name = humanizeAgentPluginId({ pluginId: plugin.pluginId });
+    // Derived from the id alone, so handles survive sorting and switching tabs.
+    const handle = `agent-plugin-${encodeURIComponent(plugin.pluginId)}`;
+    const turnOff = () => controller?.requestDisable({ pluginId: plugin.pluginId, variant: mode === 'installed' ? 'disable' : 'remove' });
+    // The switch and the button do the same thing: turning off asks first, enabling writes directly.
+    const activate = () => { if (!canWrite)
+        return; if (plugin.enabled)
+        turnOff();
+    else
+        void controller?.setEnabled({ pluginId: plugin.pluginId, enabled: true }); };
+    const verb = plugin.enabled ? 'Turn off' : 'Enable';
+    return {
+        id: plugin.pluginId, name, version: plugin.version, description: plugin.description,
+        glyph: glyphs[agentPluginGlyphKind({ plugin })], enabled: plugin.enabled, stateLabel: plugin.enabled ? 'Enabled' : 'Disabled',
+        busy, expanded, mode, canWrite, toggleLabel: `${plugin.enabled ? 'Disable' : 'Enable'} ${name}`,
+        actionLabel: `${verb} ${name}`, actionText: verb,
+        skills: plugin.skills, keywords: plugin.keywords, servers: plugin.mcpServerIds,
+        hasSkills: plugin.skills.length > 0, hasKeywords: plugin.keywords.length > 0, hasServers: plugin.mcpServerIds.length > 0,
+        toggle(_required, _optional = {}) { activate(); },
+        act(_required, _optional = {}) { activate(); },
+        expand(_required, _optional = {}) { controller?.toggleExpanded({ pluginId: plugin.pluginId }); },
+        inspect(_required, _optional = {}) { controller?.inspect({ pluginId: plugin.pluginId }); },
+        expandAttrs: { 'aria-label': `${expanded ? 'Collapse' : 'Expand'} ${name}`, 'aria-expanded': expanded, 'data-agent-handle': `${handle}-expand` },
+        actionAttrs: { 'aria-label': `${verb} ${name}`, 'data-agent-handle': `${handle}-activation` },
+        inspectAttrs: { 'data-agent-handle': `${handle}-inspect` },
+        uninstallAttrs: { 'aria-describedby': uninstallNoteId },
+        inspectLabel: `Inspect ${name} package files`, uninstallLabel: `Uninstall ${name} — unavailable`,
+    };
+}
 //# sourceMappingURL=AgentPluginPanel.hooks.js.map

package/dist/agent-plugins/react/hooks/AgentPluginsPage.hooks.d.ts

@@ -10,6 +10,19 @@ export interface AgentPluginsPageScope {
 export declare const AgentPluginsPageContext: import("react").Context<AgentPluginsPageScope | null>;
 export declare function useAgentPluginsPageScope(_required: Record<string, never>, _optional?: {}): AgentPluginsPageScope;
 export declare function useAgentPluginsPage(props: ModulePageProps, _optional?: {}): {
+    closeInspector(_required: Record<string, never>, _optional?: {}): void;
+    confirm(_required: Record<string, never>, _optional?: {}): Promise<void>;
+    cancel(_required: Record<string, never>, _optional?: {}): void;
+    inspector: {
+        pluginId: string;
+        name: string;
+    } | null;
+    confirmation: {
+        title: string;
+        confirmLabel: string;
+        body: string;
+    } | null;
+    confirming: boolean;
     denied: boolean;
     scope: {
         controller: {
@@ -47,18 +60,5 @@ export declare function useAgentPluginsPage(props: ModulePageProps, _optional?:
     onValueChange({ value }: {
         value: string;
     }, _optional?: {}): void;
-    inspector: {
-        pluginId: string;
-        name: string;
-    } | null;
-    closeInspector(_required: Record<string, never>, _optional?: {}): void;
-    confirmation: {
-        title: string;
-        confirmLabel: string;
-        body: string;
-    } | null;
-    confirming: boolean;
-    confirm(_required: Record<string, never>, _optional?: {}): Promise<void>;
-    cancel(_required: Record<string, never>, _optional?: {}): void;
 };
 //# sourceMappingURL=AgentPluginsPage.hooks.d.ts.map

package/dist/agent-plugins/react/hooks/AgentPluginsPage.hooks.js

@@ -16,24 +16,36 @@ export function useAgentPluginsPage(props, _optional = {}) {
     const permissions = props.description.visible ? props.description.grants : [], key = permissions.join('\0');
     const { controller, snapshot } = useController({ create: () => createAgentPluginsController({ api: agentPluginsApi, permissions }), dependencies: [agentPluginsApi, key] }, { start: ({ controller }) => { void controller.load({}); } });
     const [localTab, setLocalTab] = useState('installed'), uninstallNoteId = useId();
-    const visible = props.description.visible ? props.description.tabs.filter(t => t.visible) : [];
-    const active = visible.find(t => t.id.endsWith(`.${props.requestedTab ?? localTab}`)) ?? visible[0];
-    const activeId = active?.id.slice(active.id.lastIndexOf('.') + 1) ?? 'installed';
-    const pending = snapshot?.pendingDisable, confirming = !!pending && !!snapshot?.busyIds.includes(pending.pluginId);
-    const confirmation = pending ? agentPluginDisableCopy(pending) : null;
-    const inspected = snapshot?.plugins?.find(p => p.pluginId === snapshot.inspectedId);
+    const { visible, active, activeId } = pageTabs({ description: props.description, tab: props.requestedTab ?? localTab });
     return {
         denied: !props.description.visible || !permissions.includes(AGENT_PLUGINS_READ),
         scope: { controller, snapshot, permissions, uninstallNoteId },
         activeId, ActiveTab: active ? props.tabs[activeId] : undefined, params: active?.params ?? {}, permissions,
-        items: visible.map(t => ({ id: t.id.slice(t.id.lastIndexOf('.') + 1), label: t.label, content: null })),
+        items: visible.map(t => ({ id: tabSuffix(t.id), label: t.label, content: null })),
         onValueChange({ value }, _optional = {}) { setLocalTab(value); props.onTabChange?.({ tab: value }); },
-        inspector: inspected ? { pluginId: inspected.pluginId, name: humanizeAgentPluginId({ pluginId: inspected.pluginId }) } : null,
+        ...pageDialogs({ snapshot }),
         closeInspector(_required, _optional = {}) { controller?.closeInspector({}); },
-        confirmation, confirming,
-        async confirm(_required, _optional = {}) { if (!await controller?.confirmDisable({}))
-            throw new Error('Activation was not updated'); },
+        async confirm(_required, _optional = {}) {
+            const pluginId = snapshot?.pendingDisable?.pluginId ?? '(none pending)';
+            if (!await controller?.confirmDisable({}))
+                throw new Error(`Activation was not updated for agent plugin ${pluginId}: the disable was refused or failed; retry, or reload the list if it changed`);
+        },
         cancel(_required, _optional = {}) { controller?.cancelDisable({}); },
     };
 }
+/** A tab id is namespaced (`agentPlugins.installed`); the page addresses tabs by the last segment. */
+const tabSuffix = (id) => id.slice(id.lastIndexOf('.') + 1);
+function pageTabs({ description, tab }, _optional = {}) {
+    const visible = description.visible ? description.tabs.filter(t => t.visible) : [];
+    const active = visible.find(t => t.id.endsWith(`.${tab}`)) ?? visible[0];
+    return { visible, active, activeId: active ? tabSuffix(active.id) : 'installed' };
+}
+function pageDialogs({ snapshot }, _optional = {}) {
+    const pending = snapshot?.pendingDisable, confirming = !!pending && !!snapshot?.busyIds.includes(pending.pluginId);
+    const inspected = snapshot?.plugins?.find(p => p.pluginId === snapshot.inspectedId);
+    return {
+        inspector: inspected ? { pluginId: inspected.pluginId, name: humanizeAgentPluginId({ pluginId: inspected.pluginId }) } : null,
+        confirmation: pending ? agentPluginDisableCopy(pending) : null, confirming,
+    };
+}
 //# sourceMappingURL=AgentPluginsPage.hooks.js.map