@jini-ai/agent-plugins 0.4.0

package/dist/lifecycle/types.d.ts

@@ -0,0 +1,20 @@
+import type { PluginManifestAuthor } from "../manifest.js";
+/** Lifecycle value contracts shared by host ports and implementations. */
+export type AgentPluginDeliveryMode = "inject" | "pointer";
+export interface InstalledAgentPluginSkill {
+    readonly name: string;
+    readonly skillPath: string;
+}
+export interface InstalledAgentPlugin {
+    readonly pluginId: string;
+    readonly version?: (string) | undefined;
+    readonly description?: (string) | undefined;
+    readonly keywords?: (readonly string[]) | undefined;
+    readonly author?: string | PluginManifestAuthor | undefined;
+    readonly license?: (string) | undefined;
+    readonly archiveDigest: string;
+    readonly packageRoot: string;
+    readonly files: readonly string[];
+    readonly skills: readonly InstalledAgentPluginSkill[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lifecycle/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/lifecycle/uninstall.d.ts

@@ -0,0 +1,41 @@
+import type { AgentPluginLayout } from "./layout.js";
+import type { AgentPluginLifecyclePorts } from "./ports.js";
+export declare class AgentPluginNotFoundError extends Error {
+    constructor({ message }: {
+        readonly message: string;
+    }, optional?: ErrorOptions);
+}
+export declare class AgentPluginNotUninstallableError extends Error {
+    constructor({ message }: {
+        readonly message: string;
+    }, optional?: ErrorOptions);
+}
+export declare class AgentPluginChangedSincePreviewError extends Error {
+    constructor({ message }: {
+        readonly message: string;
+    }, optional?: ErrorOptions);
+}
+export interface UninstallAgentPluginRequired {
+    readonly layout: AgentPluginLayout;
+    readonly workspaceId: string;
+    readonly pluginId: string;
+}
+export interface UninstallAgentPluginOptional {
+    readonly confirmedPreview?: (AgentPluginUninstallPreview) | undefined;
+    readonly retiredBundled?: (boolean) | undefined;
+}
+export interface UninstallAgentPluginResult {
+    readonly pluginId: string;
+    readonly removedDigests: readonly string[];
+}
+export interface AgentPluginUninstallPreview {
+    readonly pluginId: string;
+    readonly versions: readonly string[];
+    readonly archiveDigests: readonly string[];
+}
+/** Internal composition; one state/queue instance per injected host context. */
+export declare function createUninstallModule(ports: AgentPluginLifecyclePorts): {
+    previewAgentPluginUninstall: (required: UninstallAgentPluginRequired) => Promise<AgentPluginUninstallPreview>;
+    uninstallAgentPlugin: (required: UninstallAgentPluginRequired, optional?: UninstallAgentPluginOptional) => Promise<UninstallAgentPluginResult>;
+};
+//# sourceMappingURL=uninstall.d.ts.map

package/dist/lifecycle/uninstall.js

@@ -0,0 +1,148 @@
+import path from "node:path";
+import { createActivationModule } from "./activation.js";
+import { createResolveAgentPluginRefsModule } from "./resolve-agent-plugin-refs.js";
+export class AgentPluginNotFoundError extends Error {
+    constructor({ message }, optional = {}) { super(message, optional); }
+}
+export class AgentPluginNotUninstallableError extends Error {
+    constructor({ message }, optional = {}) { super(message, optional); }
+}
+export class AgentPluginChangedSincePreviewError extends Error {
+    constructor({ message }, optional = {}) { super(message, optional); }
+}
+function buildModule(ports) {
+    const randomUUID = () => ports.ids.newId();
+    const chmod = ports.filesystem.chmod.bind(ports.filesystem);
+    const readdir = ports.filesystem.readdir.bind(ports.filesystem);
+    const rename = ports.filesystem.rename.bind(ports.filesystem);
+    const rm = ports.filesystem.rm.bind(ports.filesystem);
+    const stat = ports.filesystem.stat.bind(ports.filesystem);
+    const { deleteAgentPluginActivation, isAgentPluginRecordedAsBundled, resolveAgentPluginActivation } = createActivationModule(ports);
+    const { listInstalledPlugins } = createResolveAgentPluginRefsModule(ports);
+    const STAGED_DIRNAME_PREFIX = ".uninstalling-";
+    async function previewAgentPluginUninstall(required) {
+        const { matches } = await resolveUninstallTargets(required);
+        const versions = [...new Set(matches.flatMap((plugin) => (plugin.version === undefined ? [] : [plugin.version])))];
+        return { pluginId: required.pluginId, versions, archiveDigests: matches.map((plugin) => plugin.archiveDigest) };
+    }
+    async function uninstallAgentPlugin(required, optional = {}) {
+        const { workspaceRoot, packagesDir, matches } = await resolveUninstallTargets(required, optional.retiredBundled === true);
+        assertUnchangedSincePreview(required.pluginId, optional.confirmedPreview, matches);
+        const staged = [];
+        try {
+            for (const plugin of matches) {
+                staged.push(await stageForRemoval(packagesDir, plugin.packageRoot));
+            }
+            await deleteAgentPluginActivation({ workspaceRoot, pluginId: required.pluginId });
+        }
+        catch (error) {
+            throw await restoreStagedTrees(staged, error);
+        }
+        for (const tree of staged) {
+            await removeFrozenPackageTree(tree.quarantined);
+        }
+        return { pluginId: required.pluginId, removedDigests: matches.map((plugin) => plugin.archiveDigest) };
+    }
+    function assertUnchangedSincePreview(pluginId, confirmedPreview, matches) {
+        if (confirmedPreview === undefined)
+            return;
+        const previewed = [...confirmedPreview.archiveDigests].sort();
+        const installedNow = matches.map((plugin) => plugin.archiveDigest).sort();
+        if (previewed.join(",") === installedNow.join(","))
+            return;
+        throw new AgentPluginChangedSincePreviewError({ message: `Agent Plugin '${pluginId}' changed after its uninstall was previewed (previewed archive digests: ${previewed.join(", ")}; ` +
+                `installed now: ${installedNow.join(", ")}) — nothing was removed` });
+    }
+    async function stageForRemoval(packagesDir, packageRoot) {
+        const quarantined = path.join(packagesDir, `${STAGED_DIRNAME_PREFIX}${randomUUID()}`);
+        const originalMode = (await stat(packageRoot)).mode & 0o777;
+        await chmod(packageRoot, originalMode | 0o700);
+        try {
+            await rename(packageRoot, quarantined);
+        }
+        catch (error) {
+            await chmod(packageRoot, originalMode).catch(() => undefined);
+            throw error;
+        }
+        return { quarantined, original: packageRoot, originalMode };
+    }
+    async function restoreStagedTrees(staged, cause) {
+        const stranded = [];
+        for (const tree of [...staged].reverse()) {
+            try {
+                await rename(tree.quarantined, tree.original);
+                await chmod(tree.original, tree.originalMode).catch(() => undefined);
+            }
+            catch {
+                stranded.push(tree.quarantined);
+            }
+        }
+        if (stranded.length === 0)
+            return cause;
+        const reason = cause instanceof Error ? cause.message : String(cause);
+        return new Error(`Agent Plugin uninstall failed (${reason}) and ${stranded.length} package tree(s) could not be put back. ` +
+            `They still hold the package bytes and were left in place for recovery: ${stranded.join(", ")}`, { cause });
+    }
+    async function resolveUninstallTargets(required, retiredBundled = false) {
+        const { layout, workspaceId, pluginId } = required;
+        const workspaceLayout = layout.forWorkspace({ workspaceId });
+        const installed = await listInstalledPlugins(workspaceLayout.packages);
+        const matches = installed.filter((plugin) => plugin.pluginId === pluginId);
+        if (matches.length === 0) {
+            throw new AgentPluginNotFoundError({ message: `Agent Plugin '${pluginId}' is not installed in this workspace — nothing to uninstall` });
+        }
+        if (!retiredBundled && (await isAgentPluginRecordedAsBundled(workspaceLayout.root, pluginId))) {
+            throw new AgentPluginNotUninstallableError({ message: bundledRefusalMessage(pluginId) });
+        }
+        if ((await resolveAgentPluginActivation(workspaceLayout.root, pluginId)).verdict === "undetermined") {
+            throw new AgentPluginNotUninstallableError({ message: malformedEntryRefusalMessage(pluginId) });
+        }
+        return { workspaceRoot: workspaceLayout.root, packagesDir: workspaceLayout.packages, matches };
+    }
+    function bundledRefusalMessage(pluginId) {
+        return (`Agent Plugin '${pluginId}' is bundled with ${ports.productName} and cannot be uninstalled — it is re-seeded on every boot ` +
+            "(seed-bundled.ts), so removing its files now would silently reappear on the next restart. To stop it being " +
+            "used, disable it through the host's activation control.");
+    }
+    function malformedEntryRefusalMessage(pluginId) {
+        return (`Agent Plugin '${pluginId}' cannot be uninstalled: its entry in this workspace's activation record is malformed, so ` +
+            `whether it is bundled with ${ports.productName} (and would be re-seeded on the next boot) cannot be established. Nothing was ` +
+            "removed. Tell the user an operator has to repair that entry in activations.json first; until then this " +
+            "plugin's tool calls and plugin-pinned runs are refused.");
+    }
+    async function removeFrozenPackageTree(root) {
+        await makeTreeWritable(root);
+        await rm(root, { recursive: true, force: true });
+    }
+    async function makeTreeWritable(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        await chmod(dir, 0o700).catch(() => undefined);
+        for (const entry of entries) {
+            const absolute = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await makeTreeWritable(absolute);
+            }
+            else {
+                await chmod(absolute, 0o600).catch(() => undefined);
+            }
+        }
+    }
+    return { previewAgentPluginUninstall, uninstallAgentPlugin };
+}
+const instances = new WeakMap();
+/** Internal composition; one state/queue instance per injected host context. */
+export function createUninstallModule(ports) {
+    let instance = instances.get(ports);
+    if (!instance) {
+        instance = buildModule(ports);
+        instances.set(ports, instance);
+    }
+    return instance;
+}
+//# sourceMappingURL=uninstall.js.map

package/dist/lifecycle/yauzl-archive-reader.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Historical lifecycle rationale, carried with the implementation during consumer adoption.
+ * @file The real `AgentPluginArchiveReaderPort` adapter, backed by `yauzl`.
+ *
+ * Library choice (owner-decided, recorded so it is not re-litigated): `yauzl` — streaming,
+ * memory-efficient, built for a backend service parsing an untrusted uploaded archive; it enforces
+ * no policy of its own, which is exactly the shape this codebase's port+adapter discipline wants —
+ * `install.ts` owns every containment/size/entry-kind rule, this file only turns zip bytes into the
+ * `AgentPluginArchiveEntry` shape `install.ts` already knows how to harden against. Rejected:
+ * `extract-zip` (bundles its own path sanitization and writes to disk itself — it would extract
+ * past the caps `install.ts` enforces mid-stream, fighting this module's own hardening rather than
+ * feeding it); `adm-zip` (loads the whole archive into memory and blocks the event loop — the
+ * opposite of what a 32MB-capped but still untrusted upload should do); `node-unzip-2` (deprecated,
+ * known vulnerabilities). If the choice changes later, only this file and its own tests should need
+ * to move — `AgentPluginArchiveReaderPort` is the seam precisely so a library swap never touches
+ * `install.ts`'s hardening logic.
+ *
+ * ---------------------------------------------------------------------------
+ * Symlink detection — the one thing this file has to get right that yauzl doesn't do for you
+ * ---------------------------------------------------------------------------
+ * The base ZIP spec has no first-class symlink concept. The de facto convention (Info-ZIP, Python's
+ * `zipfile`, and this module's own `yazl`-based test fixtures all follow it) is: when an entry's
+ * "version made by" upper byte names a Unix host (`3`), the upper 16 bits of `externalFileAttributes`
+ * are the Unix `st_mode`, and a symlink is `(mode & S_IFMT) === S_IFLNK` — the entry's own content
+ * (its "file data") is the link target text. This module never reads that content: `install.ts`
+ * rejects every symlink-kind entry outright before any content read would matter, so decoding the
+ * target string would be pure waste against bytes that are about to be refused anyway.
+ *
+ * A zip with NO Unix "version made by" (host byte != 3, e.g. an archiver that only sets the MS-DOS
+ * convention) reports `externalFileAttributes`' upper bits as meaningless — this module only
+ * consults them when the host byte says Unix, so an ordinary non-Unix-authored zip is never
+ * misclassified as containing a symlink it doesn't have.
+ *
+ * Architectural role:
+ * Adapter only — no policy. Every hardening rule this module's header cites lives in `install.ts`
+ * and is exercised against BOTH the scripted double (`install.unit.test.ts`) and this real reader
+ * (`__tests__/unit/yauzl-archive-reader.unit.test.ts`), per the team directive that the adversarial
+ * suite is the acceptance criteria for a real archive library, not just for the double.
+ */
+/** Optional yauzl adapter. Pass the peer library explicitly; importing lifecycle never loads it. */
+export interface YauzlEntry {
+    readonly versionMadeBy: number;
+    readonly externalFileAttributes: number;
+    readonly fileName: string;
+    readonly uncompressedSize: number;
+}
+export interface YauzlZipFile {
+    eachEntry(): AsyncIterable<YauzlEntry>;
+    openReadStreamPromise(entry: YauzlEntry): Promise<AsyncIterable<Uint8Array>>;
+    close(): void;
+}
+export interface YauzlPort {
+    fromBufferPromise(buffer: Buffer, options: {
+        lazyEntries: boolean;
+        validateEntrySizes: boolean;
+    }): Promise<YauzlZipFile>;
+}
+import type { AgentPluginArchiveReaderPort } from "./install.js";
+export declare function createYauzlAgentPluginArchiveReader({ yauzl }: {
+    readonly yauzl: YauzlPort;
+}): AgentPluginArchiveReaderPort;
+//# sourceMappingURL=yauzl-archive-reader.d.ts.map

package/dist/lifecycle/yauzl-archive-reader.js

@@ -0,0 +1,73 @@
+/**
+ * Unix `st_mode` file-type mask and the symlink bit pattern within it (`S_IFMT` / `S_IFLNK`).
+ */
+const S_IFMT = 0xf000;
+const S_IFLNK = 0xa000;
+/**
+ * "Version made by" host-system byte for Unix, per the ZIP spec's APPNOTE.TXT §4.4.2.2.
+ */
+const UNIX_HOST_SYSTEM = 3;
+/**
+ * Any bit in the standard rwx-for-owner/group/other executable mask.
+ */
+const EXECUTABLE_MODE_MASK = 0o111;
+export function createYauzlAgentPluginArchiveReader({ yauzl }) {
+    return {
+        async *entries({ archive }) {
+            /**
+             * Matches install.ts's own "bytes actually observed, not declared" discipline one layer
+             * down: yauzl itself refuses to hand back a stream whose actual decompressed byte count
+             * disagrees with the entry's own declared uncompressedSize.
+             */
+            const zipfile = await yauzl.fromBufferPromise(Buffer.from(archive), {
+                lazyEntries: true,
+                validateEntrySizes: true,
+            });
+            try {
+                for await (const entry of zipfile.eachEntry()) {
+                    /**
+                     * The entry's content (the link target text) is deliberately never read — see this
+                     * module's header. `install.ts` rejects every symlink entry unconditionally.
+                     */
+                    const unixMode = readUnixMode(entry);
+                    if (entry.fileName.endsWith("/")) {
+                        yield { kind: "directory", entryPath: entry.fileName };
+                        continue;
+                    }
+                    if (unixMode !== null && (unixMode & S_IFMT) === S_IFLNK) {
+                        yield { kind: "symlink", entryPath: entry.fileName };
+                        continue;
+                    }
+                    yield {
+                        kind: "file",
+                        entryPath: entry.fileName,
+                        declaredSize: entry.uncompressedSize,
+                        executable: unixMode !== null && (unixMode & EXECUTABLE_MODE_MASK) !== 0,
+                        openReadStream: () => streamEntry(zipfile, entry),
+                    };
+                }
+            }
+            finally {
+                zipfile.close();
+            }
+        },
+    };
+}
+/**
+ * Returns the entry's Unix `st_mode`, or `null` when the archive's "version made by" does not
+ * name a Unix host — in which case `externalFileAttributes`' upper bits carry no Unix meaning and
+ * must not be interpreted as one.
+ */
+function readUnixMode(entry) {
+    const hostSystem = entry.versionMadeBy >>> 8;
+    if (hostSystem !== UNIX_HOST_SYSTEM)
+        return null;
+    return (entry.externalFileAttributes >>> 16) & 0xffff;
+}
+async function* streamEntry(zipfile, entry) {
+    const readStream = await zipfile.openReadStreamPromise(entry);
+    for await (const chunk of readStream) {
+        yield chunk;
+    }
+}
+//# sourceMappingURL=yauzl-archive-reader.js.map

package/dist/manifest.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Types for the Agent Plugins 1.0.0 open standard (published by a Technical Steering Committee
+ * with maintainers from Amazon, Cursor, Google, Microsoft, OpenAI, and Vercel). A plugin is a
+ * directory: a `plugin.json` manifest, an optional `skills/<name>/` tree following the Agent
+ * Skills spec, an optional `mcp.json` for MCP server declarations, and optional
+ * reverse-domain-namespaced directories (e.g. `com.example.client/`) for client-specific
+ * extensions that unrecognizing clients ignore.
+ *
+ * Field lists below are read from the published schemas (`AGENT_PLUGINS_SCHEMA_URL`,
+ * `AGENT_PLUGINS_MCP_SCHEMA_URL`), not inferred — both still carry an index signature since
+ * neither type asserts it has captured every future schema addition.
+ */
+export declare const AGENT_PLUGINS_SCHEMA_URL = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
+export declare const AGENT_PLUGINS_MCP_SCHEMA_URL = "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
+export declare const PLUGIN_MANIFEST_FILENAME = "plugin.json";
+export declare const PLUGIN_SKILLS_DIRNAME = "skills";
+export declare const PLUGIN_MCP_MANIFEST_FILENAME = "mcp.json";
+export interface PluginManifestAuthor {
+    readonly name?: string;
+    readonly email?: string;
+    readonly url?: string;
+}
+export interface PluginManifest {
+    readonly $schema?: string;
+    /** 1-64 chars, lowercase alphanumeric/dots/hyphens, no leading/trailing/doubled separators. */
+    readonly name: string;
+    readonly version?: string;
+    readonly description?: string;
+    readonly author?: PluginManifestAuthor;
+    readonly homepage?: string;
+    readonly repository?: string;
+    readonly license?: string;
+    readonly keywords?: readonly string[];
+    /** Reverse-domain-namespaced client extensions (e.g. `com.example.client`) — the schema assigns
+     *  no semantics to what's inside each namespace's object. */
+    readonly extensions?: Readonly<Record<string, unknown>>;
+    readonly [key: string]: unknown;
+}
+export declare function isPluginManifest(value: unknown): value is PluginManifest;
+export type McpServerEntry = {
+    readonly type: 'stdio';
+    readonly command: string;
+    readonly args?: readonly string[];
+    readonly env?: Readonly<Record<string, string>>;
+    readonly cwd?: string;
+} | {
+    readonly type: 'streamable-http';
+    readonly url: string;
+    readonly headers?: Readonly<Record<string, string>>;
+} | {
+    readonly type: 'sse';
+    readonly url: string;
+    readonly headers?: Readonly<Record<string, string>>;
+};
+export interface McpManifest {
+    readonly $schema?: string;
+    readonly mcpServers: Readonly<Record<string, McpServerEntry>>;
+}
+export declare function isMcpManifest(value: unknown): value is McpManifest;
+/** Object-argument facade for the legacy structural validator. */
+export declare function validatePluginManifest(required: {
+    readonly value: unknown;
+}): boolean;
+/** Object-argument facade for the legacy structural validator. */
+export declare function validateMcpManifest(required: {
+    readonly value: unknown;
+}): boolean;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/manifest.js

@@ -0,0 +1,38 @@
+/**
+ * Types for the Agent Plugins 1.0.0 open standard (published by a Technical Steering Committee
+ * with maintainers from Amazon, Cursor, Google, Microsoft, OpenAI, and Vercel). A plugin is a
+ * directory: a `plugin.json` manifest, an optional `skills/<name>/` tree following the Agent
+ * Skills spec, an optional `mcp.json` for MCP server declarations, and optional
+ * reverse-domain-namespaced directories (e.g. `com.example.client/`) for client-specific
+ * extensions that unrecognizing clients ignore.
+ *
+ * Field lists below are read from the published schemas (`AGENT_PLUGINS_SCHEMA_URL`,
+ * `AGENT_PLUGINS_MCP_SCHEMA_URL`), not inferred — both still carry an index signature since
+ * neither type asserts it has captured every future schema addition.
+ */
+export const AGENT_PLUGINS_SCHEMA_URL = 'https://agent-plugins.org/schemas/1.0.0/plugin.schema.json';
+export const AGENT_PLUGINS_MCP_SCHEMA_URL = 'https://agent-plugins.org/schemas/1.0.0/mcp.schema.json';
+export const PLUGIN_MANIFEST_FILENAME = 'plugin.json';
+export const PLUGIN_SKILLS_DIRNAME = 'skills';
+export const PLUGIN_MCP_MANIFEST_FILENAME = 'mcp.json';
+export function isPluginManifest(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const name = value.name;
+    return typeof name === 'string' && name.trim().length > 0;
+}
+export function isMcpManifest(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const servers = value.mcpServers;
+    return typeof servers === 'object' && servers !== null && !Array.isArray(servers);
+}
+/** Object-argument facade for the legacy structural validator. */
+export function validatePluginManifest(required) {
+    return isPluginManifest(required.value);
+}
+/** Object-argument facade for the legacy structural validator. */
+export function validateMcpManifest(required) {
+    return isMcpManifest(required.value);
+}
+//# sourceMappingURL=manifest.js.map

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "@jini-ai/agent-plugins",
+  "version": "0.4.0",
+  "description": "Support for Agent Plugins, the open, vendor-neutral spec (v1.0.0, published 2026-08-06, Technical Steering Committee with maintainers from Amazon, Cursor, Google, Microsoft, OpenAI, and Vercel) for bundling Agent Skills and MCP servers into one portable directory: PluginManifest/McpManifest types + structural validators on the package root, plus the bundled plugins themselves, each on a subpath named for itself (./ui-ux-design). Extracted 2026-08-18 from @jini-ai/plugins, which now only reserves the unrelated, unimplemented ./host format.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AINSEP/Jini.git",
+    "directory": "packages/agent-plugins"
+  },
+  "jini": {
+    "domain": "tooling",
+    "kind": "plugin-packaging",
+    "runtime": "universal",
+    "entries": {
+      ".": "universal",
+      "./ui-ux-design/*": "universal",
+      "./lifecycle": "node",
+      "./lifecycle/node": "node",
+      "./lifecycle/yauzl": "node",
+      "./manifest": "universal"
+    }
+  },
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./ui-ux-design/*": "./ui-ux-design/*",
+    "./lifecycle": {
+      "types": "./dist/lifecycle/index.d.ts",
+      "import": "./dist/lifecycle/index.js",
+      "default": "./dist/lifecycle/index.js"
+    },
+    "./lifecycle/node": {
+      "types": "./dist/lifecycle/node.d.ts",
+      "import": "./dist/lifecycle/node.js",
+      "default": "./dist/lifecycle/node.js"
+    },
+    "./lifecycle/yauzl": {
+      "types": "./dist/lifecycle/yauzl-archive-reader.d.ts",
+      "import": "./dist/lifecycle/yauzl-archive-reader.js",
+      "default": "./dist/lifecycle/yauzl-archive-reader.js"
+    },
+    "./manifest": {
+      "types": "./dist/lifecycle/manifest.d.ts",
+      "import": "./dist/lifecycle/manifest.js",
+      "default": "./dist/lifecycle/manifest.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "ui-ux-design",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map",
+    "!dist/**/__tests__/**"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^2.1.9",
+    "yazl": "^3.3.1"
+  },
+  "peerDependencies": {
+    "yauzl": "^3.4.0"
+  },
+  "peerDependenciesMeta": {
+    "yauzl": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@jini-ai/core": "^0.4.0",
+    "@jini-ai/platform": "^0.5.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  }
+}

package/ui-ux-design/com.anthropic.claude-code/hooks/hooks.json

@@ -0,0 +1,4 @@
+{
+  "$comment": "Example only, not real config. `com.anthropic.claude-code` follows the reverse-DNS convention Agent Plugins §8.2 describes (a client that controls a domain uses its reverse), but the spec publishes no namespace registry — this string is a plausible guess, not a confirmed/registered Claude Code identifier. The spec assigns no portable semantics to what's inside a client's own namespace directory in any case, so this file's shape is illustrative only.",
+  "hooks": []
+}

package/ui-ux-design/mcp.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
+  "mcpServers": {}
+}

package/ui-ux-design/plugin.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "ui-ux-design",
+  "description": "UI/UX design, interface-design-system, accessibility, and shadcn/ui component skills bundled as one portable Agent Plugin."
+}

package/ui-ux-design/skills/frontend-accessibility/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: frontend-accessibility
+version: 1.0.0
+last_updated: 2026-02-26
+description: WCAG 2.1 AA compliance guidance for frontend code review and E2E testing.
+---
+
+# Skill: Frontend Accessibility
+
+Accessibility is not a feature — it is a baseline quality requirement. A UI component that cannot be operated via keyboard or read by a screen reader is broken for a significant portion of users. This skill provides the WCAG 2.1 AA checklist that Code Inspection and QA/E2E agents use to catch violations before they ship.
+
+## WCAG 2.1 AA — What to Check in Code Inspection
+
+### Perceivable
+- All non-text content has a text alternative (`alt` on images, `aria-label` or `aria-labelledby` on icon buttons).
+- Color is not the only means of conveying information (error state must also have text or icon, not just red color).
+- Minimum contrast ratio: 4.5:1 for normal text, 3:1 for large text and UI components.
+- No content flashes more than 3 times per second.
+
+### Operable
+- All functionality accessible via keyboard (Tab, Shift+Tab, Enter, Space, Arrow keys).
+- Visible focus indicator on all interactive elements — never `outline: none` without a replacement.
+- Skip navigation link for pages with repeated navigation.
+- No keyboard traps — user can always Tab out of a component.
+
+### Understandable
+- Form inputs have associated `<label>` elements (not just placeholder text).
+- Error messages identify the field and describe the error — not just "invalid input".
+- Language attribute on `<html>` element.
+
+### Robust
+- Semantic HTML — use `<button>` for buttons, `<a>` for links, heading hierarchy (`<h1>` → `<h2>` → `<h3>`).
+- ARIA roles only when native HTML semantics are insufficient.
+- ARIA attributes used correctly — do not add `aria-label` to elements that already have visible text.
+
+## Common Violations to Flag in Code Inspection
+
+- `<div onClick>` instead of `<button>` — not keyboard accessible, no ARIA role.
+- `<img>` without `alt` attribute.
+- `<input>` without associated `<label>` (placeholder is not a label).
+- Interactive element with no visible focus state.
+- Hardcoded color values with insufficient contrast.
+- Error state communicated only via color change.
+
+## E2E Testing for Accessibility (axe-core integration)
+
+- Inject `@axe-core/playwright` in E2E tests.
+- Run `checkA11y()` after each page navigation and after dynamic content loads.
+- Configure to WCAG 2.1 AA ruleset.
+- Treat Critical and Serious violations as test failures.
+- Moderate violations are warnings — log but do not fail.
+
+## Keyboard Navigation Test Checklist
+
+- [ ] Can reach all interactive elements via Tab
+- [ ] Can activate buttons with Enter and Space
+- [ ] Can navigate dropdowns/menus with Arrow keys
+- [ ] Modals trap focus correctly (Tab stays inside modal while open)
+- [ ] Focus returns to trigger element when modal closes
+- [ ] Skip link present and functional on pages with navigation