@lesliechan721/aw-plugin-core 0.1.0-beta.7 → 0.1.0-beta.9

package/dist/manifest-contract.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import fs from 'fs-extra';
+import { computeAwCapabilitySetDigest, normalizeAwCapabilities, } from './aw-capabilities.js';
 import { normalizePluginManifestSchemaVersion, PLUGIN_MANIFEST_SCHEMA_VERSION, SOURCE_PLUGIN_MANIFEST_CONTRACT_VERSION, } from './manifest.js';
 import { readJsonFile } from './read-json.js';
 import { parsePermissionCommand } from './permission-command.js';
@@ -29,7 +30,6 @@ const PLATFORM_PRODUCT_BY_NAME = {
 };
 const PLUGIN_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const DIGEST_PATTERN = /^sha256:[0-9a-f]{64}$/;
-export const DEFAULT_SOURCE_PLUGIN_AW_MIN_VERSION = '0.0.0';
 const STRICT_SEMVER_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|(?:[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*))(?:\.(?:0|[1-9]\d*|(?:[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*)))*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/;
 export const STRICT_SEMVER_VALIDATION_CODE = 'invalidStrictSemVer';
 export class StrictSemVerValidationError extends Error {
@@ -265,30 +265,26 @@ function assertCatalogChannel(value, fieldName) {
     }
     return channel;
 }
-function createPluginCompatibility(minVersion) {
-    return {
-        aw: {
-            minVersion,
-        },
-    };
-}
-function normalizePluginCompatibility(value, fieldName, options) {
+function normalizePluginRequirements(value, fieldName, options) {
     if (value === undefined) {
-        if (options.allowMissing) {
-            return createPluginCompatibility(assertStrictSemVer(options.defaultMinVersion ?? DEFAULT_SOURCE_PLUGIN_AW_MIN_VERSION, `${fieldName}.aw.minVersion`));
-        }
-        throw new Error(`Invalid ${fieldName}.aw.minVersion: expected a strict SemVer 2.0.0 string. Received undefined.`);
+        if (options.allowMissing)
+            return undefined;
+        throw new Error(`Invalid ${fieldName}: expected an object.`);
     }
     const input = assertObject(value, fieldName);
     assertAllowedKeys(input, fieldName, ['aw']);
     const aw = assertObject(input.aw, `${fieldName}.aw`);
-    assertAllowedKeys(aw, `${fieldName}.aw`, ['minVersion']);
-    return createPluginCompatibility(assertStrictSemVer(aw.minVersion, `${fieldName}.aw.minVersion`));
-}
-function assertPluginMinVersionWithinCatalogBounds(options) {
-    if (compareStrictSemVer(options.pluginMinVersion, options.catalogMinVersion) > 0) {
-        throw new Error(`Invalid ${options.fieldName}: plugin "${options.pluginName}" requires aw ${options.pluginMinVersion}, which is higher than catalog minimum ${options.catalogMinVersion}.`);
+    assertAllowedKeys(aw, `${fieldName}.aw`, ['capabilities']);
+    if (aw.capabilities !== undefined && !Array.isArray(aw.capabilities)) {
+        throw new Error(`Invalid ${fieldName}.aw.capabilities: expected an array.`);
     }
+    return {
+        aw: {
+            ...(aw.capabilities === undefined
+                ? {}
+                : { capabilities: normalizeAwCapabilities(aw.capabilities, `${fieldName}.aw.capabilities`) }),
+        },
+    };
 }
 function normalizeMarketplaceProducts(value, fieldName) {
     if (value === undefined) {
@@ -619,15 +615,20 @@ function normalizeRuntimeExports(pluginRoot, value, fieldName) {
     return value.map((entry, index) => {
         const entryField = `${fieldName}[${index}]`;
         const input = assertObject(entry, entryField);
-        assertAllowedKeys(input, entryField, ['name', 'source']);
+        assertAllowedKeys(input, entryField, ['name', 'source', 'requires']);
         const name = normalizeRuntimeExportName(input.name, `${entryField}.name`);
         if (names.has(name)) {
             throw new Error(`Invalid ${fieldName}: duplicate export name "${name}".`);
         }
         names.add(name);
+        const requires = normalizePluginRequirements(input.requires, `${entryField}.requires`, { allowMissing: false });
+        if (requires.aw.capabilities === undefined) {
+            throw new Error(`Invalid ${entryField}.requires.aw.capabilities: expected an array.`);
+        }
         return {
             name,
             source: normalizeCanonicalPluginFilePath(pluginRoot, input.source, `${entryField}.source`),
+            requires: { aw: { capabilities: requires.aw.capabilities } },
         };
     });
 }
@@ -1394,13 +1395,24 @@ function normalizeArtifactRuntimeImports(value, fieldName, reservedImports) {
             const resolvedInput = assertObject(input.resolved, `${entryField}.resolved`);
             assertAllowedKeys(resolvedInput, `${entryField}.resolved`, [
                 'path', 'digest', 'providerPluginId', 'providerVersion', 'source',
+                'requiredCapabilities', 'capabilitySetDigest',
             ]);
+            if (!Array.isArray(resolvedInput.requiredCapabilities)) {
+                throw new Error(`Invalid ${entryField}.resolved.requiredCapabilities: expected an array.`);
+            }
+            const requiredCapabilities = normalizeAwCapabilities(resolvedInput.requiredCapabilities, `${entryField}.resolved.requiredCapabilities`);
+            const capabilitySetDigest = ensureDigestString(resolvedInput.capabilitySetDigest, `${entryField}.resolved.capabilitySetDigest`);
+            if (capabilitySetDigest !== computeAwCapabilitySetDigest(requiredCapabilities)) {
+                throw new Error(`Invalid ${entryField}.resolved.capabilitySetDigest: digest does not match requiredCapabilities.`);
+            }
             resolved = {
                 path: normalizePluginChildPath('', ensureString(resolvedInput.path, `${entryField}.resolved.path`), `${entryField}.resolved.path`),
                 digest: ensureDigestString(resolvedInput.digest, `${entryField}.resolved.digest`),
                 providerPluginId: ensureString(resolvedInput.providerPluginId, `${entryField}.resolved.providerPluginId`),
                 providerVersion: assertStrictSemVer(resolvedInput.providerVersion, `${entryField}.resolved.providerVersion`),
                 source: ensureString(resolvedInput.source, `${entryField}.resolved.source`),
+                requiredCapabilities,
+                capabilitySetDigest,
             };
         }
         return {
@@ -2006,7 +2018,7 @@ export async function assertActualNativePluginCapability(pluginRoot, manifest, m
         }
     }
     if (!skills && !slashCommands && !mcpServers && !apps && !bundled) {
-        throw new Error('Invalid plugin manifest: portable-only plugins are not supported in V1. Declare at least one non-empty native capability.');
+        throw new Error('Invalid plugin manifest: portable-only plugins are not supported. Declare at least one non-empty native capability.');
     }
 }
 export function validatePluginManifest(pluginRoot, rawManifest, options = {}) {
@@ -2020,7 +2032,7 @@ export function validatePluginManifest(pluginRoot, rawManifest, options = {}) {
         'version',
         'description',
         'dependencies',
-        'compatibility',
+        'requires',
         'skills',
         'slashCommands',
         'mcpServers',
@@ -2039,12 +2051,11 @@ export function validatePluginManifest(pluginRoot, rawManifest, options = {}) {
         name: ensureString(input.name, 'name'),
         version: assertStrictSemVer(input.version, 'plugin manifest.version'),
         description: ensureString(input.description, 'description'),
-        compatibility: normalizePluginCompatibility(input.compatibility, 'compatibility', {
-            allowMissing: (options.compatibilityMode ?? 'defaulted') === 'defaulted',
-            defaultMinVersion: options.defaultMinVersion,
-        }),
         marketplace: normalizeMarketplaceMeta(input.marketplace, 'marketplace'),
     };
+    const requires = normalizePluginRequirements(input.requires, 'requires', { allowMissing: true });
+    if (requires !== undefined)
+        manifest.requires = requires;
     if (input.dependencies !== undefined) {
         const dependencies = ensureStringArray(input.dependencies, 'dependencies');
         if (dependencies.length > 64) {
@@ -2289,18 +2300,7 @@ async function validateSourceJsonNativeAsset(pluginRoot, manifest, field) {
 }
 export async function validateSourcePluginManifest(pluginRoot, rawManifest, options = {}) {
     await assertPluginInputTree(pluginRoot);
-    const distributionsInput = rawManifest !== null
-        && typeof rawManifest === 'object'
-        && !Array.isArray(rawManifest)
-        ? rawManifest.distributions
-        : undefined;
-    const requiresExplicitMinVersion = distributionsInput !== null
-        && typeof distributionsInput === 'object'
-        && !Array.isArray(distributionsInput)
-        && Object.hasOwn(distributionsInput, 'agentSkills');
     const manifest = validatePluginManifest(pluginRoot, rawManifest, {
-        compatibilityMode: requiresExplicitMinVersion ? 'required' : 'defaulted',
-        defaultMinVersion: DEFAULT_SOURCE_PLUGIN_AW_MIN_VERSION,
         reservedImports: options.reservedImports,
     });
     const parsedVersion = parseStrictSemVer(manifest.version, 'plugin manifest.version');
@@ -2337,10 +2337,7 @@ export async function readPluginManifest(pluginRoot, options = {}) {
         ? await validateSourcePluginManifest(pluginRoot, rawManifest, {
             reservedImports: options.reservedImports,
         })
-        : validatePluginManifest(pluginRoot, rawManifest, {
-            compatibilityMode: 'required',
-            reservedImports: options.reservedImports,
-        });
+        : validatePluginManifest(pluginRoot, rawManifest, { reservedImports: options.reservedImports });
     if (mode === 'bundle')
         await assertActualNativePluginCapability(pluginRoot, manifest, 'bundle');
     return {
@@ -2438,9 +2435,6 @@ function assertCatalogChannelVersionContract(options) {
 }
 function normalizeCatalogManifestEntry(value, fieldName) {
     const input = assertObject(value, fieldName);
-    if (Object.hasOwn(input, 'dependencies')) {
-        throw new Error(`Invalid ${fieldName}: "dependencies" is unsupported.`);
-    }
     assertAllowedKeys(input, fieldName, [
         'name',
         'version',
@@ -2450,7 +2444,8 @@ function normalizeCatalogManifestEntry(value, fieldName) {
         'tags',
         'strict',
         'policy',
-        'compatibility',
+        'dependencies',
+        'requires',
         'source',
         'artifactDigest',
         'manifestDigest',
@@ -2462,7 +2457,11 @@ function normalizeCatalogManifestEntry(value, fieldName) {
         category: ensureString(input.category, `${fieldName}.category`),
         strict: ensureBoolean(input.strict, `${fieldName}.strict`),
         policy: normalizeMarketplacePolicy(input.policy, `${fieldName}.policy`),
-        compatibility: normalizePluginCompatibility(input.compatibility, `${fieldName}.compatibility`, {
+        dependencies: input.dependencies === undefined
+            ? []
+            : normalizeComparableStringArray(ensureStringArray(input.dependencies, `${fieldName}.dependencies`))
+                .map((dependency, index) => ensurePluginName(dependency, `${fieldName}.dependencies[${index}]`)),
+        requires: normalizePluginRequirements(input.requires, `${fieldName}.requires`, {
             allowMissing: false,
         }),
         source: normalizeCatalogRelativePath(input.source, `${fieldName}.source`),
@@ -2486,8 +2485,8 @@ export function normalizeCatalogManifestBase(input, fieldName) {
         fieldName: `${fieldName}.catalogVersion`,
         kind: 'catalog',
     });
-    const compatibility = normalizePluginCompatibility(input.compatibility, `${fieldName}.compatibility`, { allowMissing: false });
-    return { catalogVersion, channel, compatibility };
+    const requires = normalizePluginRequirements(input.requires, `${fieldName}.requires`, { allowMissing: false });
+    return { catalogVersion, channel, requires };
 }
 export function normalizeCatalogManifestEntries(rawEntries, base, fieldName) {
     if (!Array.isArray(rawEntries)) {
@@ -2508,16 +2507,10 @@ export function normalizeCatalogManifestEntries(rawEntries, base, fieldName) {
                 kind: 'plugin',
             });
         }
-        assertPluginMinVersionWithinCatalogBounds({
-            pluginName: entry.name,
-            pluginMinVersion: entry.compatibility.aw.minVersion,
-            catalogMinVersion: base.compatibility.aw.minVersion,
-            fieldName: `${fieldName}.entries.${entry.name}.compatibility.aw.minVersion`,
-        });
     }
     return entries;
 }
-export function createBundleSourceManifest(plugin) {
+export function createBundleSourceManifest(plugin, requiredCapabilities) {
     const scripts = plugin.manifest.scripts
         ? structuredClone(plugin.manifest.scripts)
         : undefined;
@@ -2543,9 +2536,12 @@ export function createBundleSourceManifest(plugin) {
     return {
         ...plugin.manifest,
         buildConfig,
-        compatibility: plugin.manifest.compatibility
-            ? structuredClone(plugin.manifest.compatibility)
-            : createPluginCompatibility(DEFAULT_SOURCE_PLUGIN_AW_MIN_VERSION),
+        distributions: plugin.manifest.distributions
+            ? structuredClone(plugin.manifest.distributions)
+            : undefined,
+        requires: requiredCapabilities === undefined
+            ? structuredClone(plugin.manifest.requires)
+            : { aw: { capabilities: normalizeAwCapabilities(requiredCapabilities) } },
         extensions: plugin.manifest.extensions
             ? {
                 instructions: plugin.manifest.extensions.instructions
@@ -2580,11 +2576,6 @@ export function createPlatformManifestBase(plugin) {
         name: plugin.manifest.name,
         version: plugin.manifest.version,
         description: plugin.manifest.description,
-        compatibility: structuredClone(plugin.manifest.compatibility ?? {
-            aw: {
-                minVersion: '0.0.0',
-            },
-        }),
         interface: plugin.manifest.interface,
     };
 }