@jini-ai/admin 0.3.10 → 0.4.1

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

@@ -0,0 +1,74 @@
+import { useEffect, useId, useRef, useState } from 'react';
+import { useController } from '../../../react/use-controller.js';
+import { createAgentPluginFilesController } from '../../controllers/agent-plugin-files.controller.js';
+import { useAgentPluginsPorts } from './AgentPluginsPorts.hooks.js';
+import { AGENT_PLUGINS_READ, agentPluginFileNotice, selectAgentPluginFile } from '../../rules.js';
+import { ancestorFolderPaths, buildPackageFileTree, visiblePackageFileRows, packageFileTreeKeyAction, packageFileIconKind } from '../../package-file-tree.js';
+import { agentPluginsMessagesEn as m } from '../../messages.en.js';
+export function useAgentPluginInspector({ pluginId, permissions, name }, _optional = {}) {
+    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,
+        select({ path }, _optional = {}) { controller?.select({ path }); },
+    };
+}
+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());
+    const [focused, setFocused] = useState(null), treeRef = useRef(null), moveFocus = useRef(false);
+    // Expansion is derived from selected ancestors until the viewer explicitly toggles a folder.
+    const ancestors = new Set(selectedPath ? ancestorFolderPaths({ filePath: selectedPath }) : []);
+    const isExpanded = ({ path }) => toggled.get(path) ?? ancestors.has(path);
+    const rows = visiblePackageFileRows({ nodes: tree, isExpanded });
+    const visible = (path) => path !== null && rows.some(r => r.node.path === path);
+    const activePath = visible(focused) ? focused : visible(selectedPath) ? selectedPath : rows[0]?.node.path ?? null;
+    // Move DOM focus only after keyboard navigation, never when opening the inspector.
+    useEffect(() => { if (!moveFocus.current)
+        return; moveFocus.current = false; Array.from(treeRef.current?.querySelectorAll('[data-tree-path]') ?? []).find(el => el.dataset.treePath === activePath)?.focus(); });
+    const setExpanded = (path, expanded) => setToggled(current => new Map(current).set(path, expanded));
+    return { treeRef,
+        rows: rows.map(row => {
+            const { node } = row, folder = node.kind === 'folder', expanded = folder && isExpanded({ path: node.path });
+            return { key: `${node.kind}:${node.path}`, name: node.name, path: node.path, depth: row.depth + 1, setSize: row.setSize, posInSet: row.posInSet, expanded: folder ? expanded : undefined, selected: folder ? undefined : node.path === selectedPath, tabIndex: node.path === activePath ? 0 : -1,
+                icon: folder ? expanded ? '▾' : '▸' : fileGlyphs[packageFileIconKind({ fileName: node.name })], indent: { paddingInlineStart: `${row.depth * 1.25}rem`, ...(node.kind === 'file' && node.path === selectedPath ? { backgroundColor: 'Highlight', color: 'HighlightText' } : {}) },
+                onClick() { setFocused(node.path); if (folder)
+                    setExpanded(node.path, !expanded);
+                else
+                    onOpen({ path: node.path }); }, onFocus() { setFocused(node.path); },
+            };
+        }),
+        onKeyDown(event) {
+            if (activePath === null)
+                return;
+            const action = packageFileTreeKeyAction({ rows, currentPath: activePath, key: event.key, isExpanded });
+            if (!action.focus && !action.setExpanded && !action.open)
+                return;
+            event.preventDefault();
+            if (action.setExpanded)
+                setExpanded(action.setExpanded.path, action.setExpanded.expanded);
+            if (action.open)
+                onOpen({ path: action.open });
+            if (action.focus) {
+                setFocused(action.focus);
+                moveFocus.current = true;
+            }
+        },
+    };
+}
+export function useAgentPluginFileContent({ file }, _optional = {}) {
+    const [wrap, setWrap] = useState(true), headingId = useId(), notice = agentPluginFileNotice({ file });
+    // One grid row per source line keeps gutter numbers aligned when long lines wrap.
+    const lines = (file.content ?? '').split('\n').map((text, index) => ({ text, number: index + 1 }));
+    return { headingId, path: file.relativePath, segments: file.relativePath.split('/').map((text, i, all) => ({ text, slash: i < all.length - 1 })), notice, hasContent: notice === null, lines, wrap,
+        wrapAttrs: { 'aria-pressed': wrap }, wrapText: wrap ? 'Wrap: on' : 'Wrap: off',
+        codeStyle: { display: 'grid', gridTemplateColumns: 'max-content minmax(0, 1fr)', overflow: 'auto' },
+        lineStyle: { whiteSpace: wrap ? 'pre-wrap' : 'pre', overflowWrap: wrap ? 'anywhere' : 'normal' },
+        toggleWrap(_required, _optional = {}) { setWrap(value => !value); },
+    };
+}
+//# sourceMappingURL=AgentPluginInspector.hooks.js.map

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

@@ -0,0 +1,67 @@
+import type { TabViewProps } from '../../../react/bind-react.js';
+export declare function useAgentPluginPanel({ props, mode }: {
+    props: TabViewProps;
+    mode: 'installed' | 'downloaded';
+}, _optional?: {}): {
+    denied: boolean;
+    mode: "installed" | "downloaded";
+    rows: {
+        id: string;
+        name: string;
+        version: string | null | undefined;
+        description: string | null | undefined;
+        glyph: string;
+        enabled: boolean;
+        stateLabel: string;
+        busy: boolean;
+        expanded: boolean;
+        mode: "installed" | "downloaded";
+        canWrite: boolean;
+        toggleLabel: string;
+        actionLabel: string;
+        actionText: string;
+        skills: readonly (Pick<import("@jini-ai/agent-plugins/lifecycle").InstalledAgentPluginSkill, "name"> & {
+            readonly summary: string;
+        })[];
+        keywords: readonly string[];
+        servers: readonly string[];
+        hasSkills: boolean;
+        hasKeywords: boolean;
+        hasServers: boolean;
+        toggle(_required: {
+            checked: boolean;
+        }, _optional?: {}): void;
+        act(_required: Record<string, never>, _optional?: {}): void;
+        expand(_required: Record<string, never>, _optional?: {}): void;
+        inspect(_required: Record<string, never>, _optional?: {}): void;
+        expandAttrs: {
+            'aria-label': string;
+            'aria-expanded': boolean;
+            'data-agent-handle': string;
+        };
+        actionAttrs: {
+            'aria-label': string;
+            'data-agent-handle': string;
+        };
+        inspectAttrs: {
+            'data-agent-handle': string;
+        };
+        uninstallAttrs: {
+            'aria-describedby': string;
+        };
+        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];
+//# sourceMappingURL=AgentPluginPanel.hooks.d.ts.map

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

@@ -0,0 +1,50 @@
+import { agentPluginsMessagesEn as m } from '../../messages.en.js';
+import { AGENT_PLUGINS_READ, AGENT_PLUGINS_WRITE, AGENT_PLUGINS_SPEC_URL, humanizeAgentPluginId, agentPluginGlyphKind } from '../../rules.js';
+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 rows = (canRead ? state?.plugins ?? [] : []).map(plugin => {
+        const name = humanizeAgentPluginId({ pluginId: plugin.pluginId }), busy = state?.busyIds.includes(plugin.pluginId) ?? false;
+        const expanded = state?.expandedIds.includes(plugin.pluginId) ?? false;
+        // 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,
+        uninstallNoteId, specUrl: AGENT_PLUGINS_SPEC_URL,
+        reload(_required, _optional = {}) { void controller?.load({}); },
+    };
+}
+//# sourceMappingURL=AgentPluginPanel.hooks.js.map

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

@@ -0,0 +1,55 @@
+import type { AgentPluginRowView } from './AgentPluginPanel.hooks.js';
+export declare function useAgentPluginRow({ row }: {
+    row: AgentPluginRowView;
+}, _optional?: {}): {
+    detailId: string;
+    expandAttrs: {
+        'aria-controls': string;
+        'aria-label': string;
+        'aria-expanded': boolean;
+        'data-agent-handle': string;
+    };
+    installed: boolean;
+    detailHidden: boolean;
+    id: string;
+    name: string;
+    version: string | null | undefined;
+    description: string | null | undefined;
+    glyph: string;
+    enabled: boolean;
+    stateLabel: string;
+    busy: boolean;
+    expanded: boolean;
+    mode: "installed" | "downloaded";
+    canWrite: boolean;
+    toggleLabel: string;
+    actionLabel: string;
+    actionText: string;
+    skills: readonly (Pick<import("@jini-ai/agent-plugins/lifecycle").InstalledAgentPluginSkill, "name"> & {
+        readonly summary: string;
+    })[];
+    keywords: readonly string[];
+    servers: readonly string[];
+    hasSkills: boolean;
+    hasKeywords: boolean;
+    hasServers: boolean;
+    toggle(_required: {
+        checked: boolean;
+    }, _optional?: {}): void;
+    act(_required: Record<string, never>, _optional?: {}): void;
+    expand(_required: Record<string, never>, _optional?: {}): void;
+    inspect(_required: Record<string, never>, _optional?: {}): void;
+    actionAttrs: {
+        'aria-label': string;
+        'data-agent-handle': string;
+    };
+    inspectAttrs: {
+        'data-agent-handle': string;
+    };
+    uninstallAttrs: {
+        'aria-describedby': string;
+    };
+    inspectLabel: string;
+    uninstallLabel: string;
+};
+//# sourceMappingURL=AgentPluginRow.hooks.d.ts.map

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

@@ -0,0 +1,6 @@
+import { useId } from 'react';
+export function useAgentPluginRow({ row }, _optional = {}) {
+    const detailId = useId();
+    return { ...row, detailId, expandAttrs: { ...row.expandAttrs, 'aria-controls': detailId }, installed: row.mode === 'installed', detailHidden: !row.expanded };
+}
+//# sourceMappingURL=AgentPluginRow.hooks.js.map

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

@@ -0,0 +1,64 @@
+import type { ModulePageProps } from '../../../react/bind-react.js';
+import { createAgentPluginsController } from '../../controllers/agent-plugins.controller.js';
+import type { AgentPluginsState } from '../../models.js';
+export interface AgentPluginsPageScope {
+    readonly controller: ReturnType<typeof createAgentPluginsController> | null;
+    readonly snapshot: Readonly<AgentPluginsState> | null;
+    readonly permissions: readonly string[];
+    readonly uninstallNoteId: string;
+}
+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?: {}): {
+    denied: boolean;
+    scope: {
+        controller: {
+            getSnapshot: () => Readonly<AgentPluginsState>;
+            subscribe: ({ listener }: {
+                listener: () => void;
+            }) => () => void;
+            load: (_required: Record<string, never>, _optional?: {}) => Promise<void>;
+            setEnabled: (input: import("../../models.js").AgentPluginActivationInput, _optional?: {}) => Promise<boolean>;
+            requestDisable(input: import("../../models.js").AgentPluginDisableRequest, _optional?: {}): void;
+            cancelDisable(_required: Record<string, never>, _optional?: {}): void;
+            confirmDisable(_required: Record<string, never>, _optional?: {}): Promise<boolean>;
+            toggleExpanded({ pluginId }: {
+                pluginId: string;
+            }, _optional?: {}): void;
+            inspect({ pluginId }: {
+                pluginId: string;
+            }, _optional?: {}): void;
+            closeInspector(_required: Record<string, never>, _optional?: {}): void;
+            dispose(_required?: Record<string, never>, _optional?: {}): void;
+        } | null;
+        snapshot: Readonly<AgentPluginsState> | null;
+        permissions: readonly string[];
+        uninstallNoteId: string;
+    };
+    activeId: string;
+    ActiveTab: import("react").LazyExoticComponent<import("react").ComponentType<import("../../../react/bind-react.js").TabViewProps>> | undefined;
+    params: Readonly<Record<string, unknown>>;
+    permissions: readonly string[];
+    items: {
+        id: string;
+        label: string;
+        content: null;
+    }[];
+    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

@@ -0,0 +1,39 @@
+import { createContext, useContext, useId, useState } from 'react';
+import { useController } from '../../../react/use-controller.js';
+import { createAgentPluginsController } from '../../controllers/agent-plugins.controller.js';
+import { AGENT_PLUGINS_READ, agentPluginDisableCopy, humanizeAgentPluginId } from '../../rules.js';
+import { useAgentPluginsPorts } from './AgentPluginsPorts.hooks.js';
+import { AdminConfigError } from '../../../core/module/index.js';
+export const AgentPluginsPageContext = createContext(null);
+export function useAgentPluginsPageScope(_required, _optional = {}) {
+    const scope = useContext(AgentPluginsPageContext);
+    if (!scope)
+        throw new AdminConfigError({ issues: ['Agent plugins page scope unavailable'] });
+    return scope;
+}
+export function useAgentPluginsPage(props, _optional = {}) {
+    const { agentPluginsApi } = useAgentPluginsPorts({});
+    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);
+    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 })),
+        onValueChange({ value }, _optional = {}) { setLocalTab(value); props.onTabChange?.({ tab: value }); },
+        inspector: inspected ? { pluginId: inspected.pluginId, name: humanizeAgentPluginId({ pluginId: inspected.pluginId }) } : null,
+        closeInspector(_required, _optional = {}) { controller?.closeInspector({}); },
+        confirmation, confirming,
+        async confirm(_required, _optional = {}) { if (!await controller?.confirmDisable({}))
+            throw new Error('Activation was not updated'); },
+        cancel(_required, _optional = {}) { controller?.cancelDisable({}); },
+    };
+}
+//# sourceMappingURL=AgentPluginsPage.hooks.js.map

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

@@ -0,0 +1,7 @@
+import type { AgentPluginsApiPort } from '../../ports.js';
+export interface AgentPluginsPorts {
+    readonly agentPluginsApi: AgentPluginsApiPort;
+}
+export declare const AgentPluginsPortsContext: import("react").Context<AgentPluginsPorts | null>;
+export declare function useAgentPluginsPorts(_required?: Record<string, never>, _optional?: {}): AgentPluginsPorts;
+//# sourceMappingURL=AgentPluginsPorts.hooks.d.ts.map

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

@@ -0,0 +1,10 @@
+import { createContext, useContext } from 'react';
+import { AdminConfigError } from '../../../core/module/index.js';
+export const AgentPluginsPortsContext = createContext(null);
+export function useAgentPluginsPorts(_required = {}, _optional = {}) {
+    const ports = useContext(AgentPluginsPortsContext);
+    if (!ports)
+        throw new AdminConfigError({ issues: ['React scope unavailable: agent-plugins'] });
+    return ports;
+}
+//# sourceMappingURL=AgentPluginsPorts.hooks.js.map

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

@@ -0,0 +1,6 @@
+import type { TabViewProps } from '../../../react/bind-react.js';
+export declare function useMarketplaceTab({ permissions }: TabViewProps, _optional?: {}): {
+    denied: boolean;
+    specUrl: string;
+};
+//# sourceMappingURL=MarketplaceTab.hooks.d.ts.map

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

@@ -0,0 +1,3 @@
+import { AGENT_PLUGINS_READ, AGENT_PLUGINS_SPEC_URL } from '../../rules.js';
+export function useMarketplaceTab({ permissions = [] }, _optional = {}) { return { denied: !permissions.includes(AGENT_PLUGINS_READ), specUrl: AGENT_PLUGINS_SPEC_URL }; }
+//# sourceMappingURL=MarketplaceTab.hooks.js.map

package/dist/agent-plugins/react/index.d.ts

@@ -0,0 +1,245 @@
+export { useAgentPluginsPorts } from './hooks/AgentPluginsPorts.hooks.js';
+/** Host-owned bundled policy copy. All page/tab loaders remain lazy. */
+export declare function agentPlugins(_required: Record<string, never>, { uninstallNotice }?: {
+    uninstallNotice?: string;
+}): {
+    pages: {
+        agentPlugins: {
+            tabs: {
+                installed: {
+                    params: {
+                        uninstallNotice: string;
+                    };
+                    label: "Installed";
+                };
+                downloaded: {
+                    params: {
+                        uninstallNotice: string;
+                    };
+                    label: "Downloaded";
+                };
+                marketplace: {
+                    readonly label: "Marketplace";
+                };
+            };
+            path: "/agent-plugins";
+            label: "Agent Plugins";
+            permissions: readonly ["admin.plugins.read"];
+            nav: {
+                readonly group: "operations";
+                readonly icon: "package";
+            };
+        };
+    };
+    id: "agent-plugins";
+    requires: {
+        readonly agentPluginsApi: import("../../core/module/token.js").AdminPortToken<import("../ports.js").AgentPluginsApiPort, "admin.agent-plugins.api">;
+    };
+    messages: {
+        readonly title: "Agent Plugins";
+        readonly installed: "Installed";
+        readonly downloaded: "Downloaded";
+        readonly marketplace: "Marketplace";
+        readonly description: "Portable packages installed for this workspace.";
+        readonly denied: "Permission denied";
+        readonly loading: "Loading Agent Plugins…";
+        readonly empty: "No Agent Plugins are installed in this workspace.";
+        readonly loadError: "Failed to load agent plugins";
+        readonly actionError: "Failed to update agent plugin";
+        readonly fileError: "Failed to load package files";
+        readonly filesLoading: "Loading package files…";
+        readonly filesEmpty: "No files to show for this plugin.";
+        readonly filesTruncated: "Some files are not listed: this package is larger than the viewer’s limits.";
+        readonly installedLede: "Every plugin installed in this workspace. Only switched-on plugins reach the assistant’s prompt.";
+        readonly downloadedLede: "An installed plugin sits inert until you enable it. Enabling one puts its skills in the assistant’s prompt for every run.";
+        readonly uninstallUnavailable: "Uninstall is unavailable in this view. Package removal is managed by the host.";
+        readonly marketplaceTitle: "Nothing to browse yet";
+        readonly marketplaceDescription: "Marketplace is planned for a future release. This view does not fetch, install, or list marketplace packages yet.";
+        readonly marketplaceHint: "Until then, the Downloaded tab lists the packages available in this workspace.";
+    };
+} & {
+    react: {
+        module: {
+            pages: {
+                agentPlugins: {
+                    tabs: {
+                        installed: {
+                            params: {
+                                uninstallNotice: string;
+                            };
+                            label: "Installed";
+                        };
+                        downloaded: {
+                            params: {
+                                uninstallNotice: string;
+                            };
+                            label: "Downloaded";
+                        };
+                        marketplace: {
+                            readonly label: "Marketplace";
+                        };
+                    };
+                    path: "/agent-plugins";
+                    label: "Agent Plugins";
+                    permissions: readonly ["admin.plugins.read"];
+                    nav: {
+                        readonly group: "operations";
+                        readonly icon: "package";
+                    };
+                };
+            };
+            id: "agent-plugins";
+            requires: {
+                readonly agentPluginsApi: import("../../core/module/token.js").AdminPortToken<import("../ports.js").AgentPluginsApiPort, "admin.agent-plugins.api">;
+            };
+            messages: {
+                readonly title: "Agent Plugins";
+                readonly installed: "Installed";
+                readonly downloaded: "Downloaded";
+                readonly marketplace: "Marketplace";
+                readonly description: "Portable packages installed for this workspace.";
+                readonly denied: "Permission denied";
+                readonly loading: "Loading Agent Plugins…";
+                readonly empty: "No Agent Plugins are installed in this workspace.";
+                readonly loadError: "Failed to load agent plugins";
+                readonly actionError: "Failed to update agent plugin";
+                readonly fileError: "Failed to load package files";
+                readonly filesLoading: "Loading package files…";
+                readonly filesEmpty: "No files to show for this plugin.";
+                readonly filesTruncated: "Some files are not listed: this package is larger than the viewer’s limits.";
+                readonly installedLede: "Every plugin installed in this workspace. Only switched-on plugins reach the assistant’s prompt.";
+                readonly downloadedLede: "An installed plugin sits inert until you enable it. Enabling one puts its skills in the assistant’s prompt for every run.";
+                readonly uninstallUnavailable: "Uninstall is unavailable in this view. Package removal is managed by the host.";
+                readonly marketplaceTitle: "Nothing to browse yet";
+                readonly marketplaceDescription: "Marketplace is planned for a future release. This view does not fetch, install, or list marketplace packages yet.";
+                readonly marketplaceHint: "Until then, the Downloaded tab lists the packages available in this workspace.";
+            };
+        };
+        pages: {
+            agentPlugins: {
+                Page: import("react").LazyExoticComponent<import("react").ComponentType<import("../../react/bind-react.js").ModulePageProps>>;
+                tabs: {
+                    installed: import("react").LazyExoticComponent<import("react").ComponentType<import("../../react/bind-react.js").TabViewProps>>;
+                    downloaded: import("react").LazyExoticComponent<import("react").ComponentType<import("../../react/bind-react.js").TabViewProps>>;
+                    marketplace: import("react").LazyExoticComponent<import("react").ComponentType<import("../../react/bind-react.js").TabViewProps>>;
+                };
+            };
+        };
+        Provider: ({ admin, children }: {
+            admin: import("../../core/module/types.js").AdminInstance;
+            children: import("react").ReactNode;
+        }, _optional?: Record<string, never>) => import("react").FunctionComponentElement<import("react").ProviderProps<import("../../core/module/types.js").ScopedPorts<{
+            pages: {
+                agentPlugins: {
+                    tabs: {
+                        installed: {
+                            params: {
+                                uninstallNotice: string;
+                            };
+                            label: "Installed";
+                        };
+                        downloaded: {
+                            params: {
+                                uninstallNotice: string;
+                            };
+                            label: "Downloaded";
+                        };
+                        marketplace: {
+                            readonly label: "Marketplace";
+                        };
+                    };
+                    path: "/agent-plugins";
+                    label: "Agent Plugins";
+                    permissions: readonly ["admin.plugins.read"];
+                    nav: {
+                        readonly group: "operations";
+                        readonly icon: "package";
+                    };
+                };
+            };
+            id: "agent-plugins";
+            requires: {
+                readonly agentPluginsApi: import("../../core/module/token.js").AdminPortToken<import("../ports.js").AgentPluginsApiPort, "admin.agent-plugins.api">;
+            };
+            messages: {
+                readonly title: "Agent Plugins";
+                readonly installed: "Installed";
+                readonly downloaded: "Downloaded";
+                readonly marketplace: "Marketplace";
+                readonly description: "Portable packages installed for this workspace.";
+                readonly denied: "Permission denied";
+                readonly loading: "Loading Agent Plugins…";
+                readonly empty: "No Agent Plugins are installed in this workspace.";
+                readonly loadError: "Failed to load agent plugins";
+                readonly actionError: "Failed to update agent plugin";
+                readonly fileError: "Failed to load package files";
+                readonly filesLoading: "Loading package files…";
+                readonly filesEmpty: "No files to show for this plugin.";
+                readonly filesTruncated: "Some files are not listed: this package is larger than the viewer’s limits.";
+                readonly installedLede: "Every plugin installed in this workspace. Only switched-on plugins reach the assistant’s prompt.";
+                readonly downloadedLede: "An installed plugin sits inert until you enable it. Enabling one puts its skills in the assistant’s prompt for every run.";
+                readonly uninstallUnavailable: "Uninstall is unavailable in this view. Package removal is managed by the host.";
+                readonly marketplaceTitle: "Nothing to browse yet";
+                readonly marketplaceDescription: "Marketplace is planned for a future release. This view does not fetch, install, or list marketplace packages yet.";
+                readonly marketplaceHint: "Until then, the Downloaded tab lists the packages available in this workspace.";
+            };
+        }> | null>>;
+        usePorts: (_required?: Record<string, never>, _optional?: Record<string, never>) => import("../../core/module/types.js").ScopedPorts<{
+            pages: {
+                agentPlugins: {
+                    tabs: {
+                        installed: {
+                            params: {
+                                uninstallNotice: string;
+                            };
+                            label: "Installed";
+                        };
+                        downloaded: {
+                            params: {
+                                uninstallNotice: string;
+                            };
+                            label: "Downloaded";
+                        };
+                        marketplace: {
+                            readonly label: "Marketplace";
+                        };
+                    };
+                    path: "/agent-plugins";
+                    label: "Agent Plugins";
+                    permissions: readonly ["admin.plugins.read"];
+                    nav: {
+                        readonly group: "operations";
+                        readonly icon: "package";
+                    };
+                };
+            };
+            id: "agent-plugins";
+            requires: {
+                readonly agentPluginsApi: import("../../core/module/token.js").AdminPortToken<import("../ports.js").AgentPluginsApiPort, "admin.agent-plugins.api">;
+            };
+            messages: {
+                readonly title: "Agent Plugins";
+                readonly installed: "Installed";
+                readonly downloaded: "Downloaded";
+                readonly marketplace: "Marketplace";
+                readonly description: "Portable packages installed for this workspace.";
+                readonly denied: "Permission denied";
+                readonly loading: "Loading Agent Plugins…";
+                readonly empty: "No Agent Plugins are installed in this workspace.";
+                readonly loadError: "Failed to load agent plugins";
+                readonly actionError: "Failed to update agent plugin";
+                readonly fileError: "Failed to load package files";
+                readonly filesLoading: "Loading package files…";
+                readonly filesEmpty: "No files to show for this plugin.";
+                readonly filesTruncated: "Some files are not listed: this package is larger than the viewer’s limits.";
+                readonly installedLede: "Every plugin installed in this workspace. Only switched-on plugins reach the assistant’s prompt.";
+                readonly downloadedLede: "An installed plugin sits inert until you enable it. Enabling one puts its skills in the assistant’s prompt for every run.";
+                readonly uninstallUnavailable: "Uninstall is unavailable in this view. Package removal is managed by the host.";
+                readonly marketplaceTitle: "Nothing to browse yet";
+                readonly marketplaceDescription: "Marketplace is planned for a future release. This view does not fetch, install, or list marketplace packages yet.";
+                readonly marketplaceHint: "Until then, the Downloaded tab lists the packages available in this workspace.";
+            };
+        }>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map