@aopslabs/aops 0.3.31 → 0.3.33

package/dist/lib/agent-assets/hosted-discovery.js

@@ -1,148 +0,0 @@
-import { invokeHostedToolWithApiState, unwrapHostedToolResult } from '../../utils/agent-gateway.js';
-import { createCliApiClientFromOptions } from '../../utils/api.js';
-import { AgentAssetsError } from './envelope.js';
-const MATCH_FIELD = /^(?:name|shortDescription|description|tags|version|entryFile|skillStandard|meta\.[A-Za-z0-9_.-]+)$/;
-const EXACT_REF = /^skill-version:(.+)$/;
-const SHA256_HEX = /^[a-f0-9]{64}$/;
-const FORBIDDEN_BODY_KEYS = new Set([
-    'content',
-    'files',
-    'filesystemPath',
-    'materializedPath',
-    'outputDir',
-    'packagePath',
-    'serverPath',
-    'sourcePath',
-]);
-function discoveryError(message, details) {
-    return new AgentAssetsError('schema_incompatible', message, {
-        nextActions: [
-            'Inspect `aops-cli agent schema --tool agentspace.skill.search --summary`; do not load skill bodies to compensate.',
-        ],
-        ...(details === undefined ? {} : { details }),
-    });
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function unwrapData(value) {
-    let current = value;
-    for (let depth = 0; depth < 3; depth += 1) {
-        if (!isRecord(current) || !Object.prototype.hasOwnProperty.call(current, 'data'))
-            break;
-        current = current.data;
-    }
-    return current;
-}
-function assertMetadataOnly(value) {
-    if (!value || typeof value !== 'object')
-        return;
-    for (const [key, child] of Object.entries(value)) {
-        if (FORBIDDEN_BODY_KEYS.has(key)) {
-            throw new AgentAssetsError('untrusted_origin', `Hosted discovery returned forbidden body/path field: ${key}.`, {
-                nextActions: ['Use only the raw metadata `agentspace.skill.search` Community projection.'],
-            });
-        }
-        assertMetadataOnly(child);
-    }
-}
-function boundedString(record, key, maximum, required = true) {
-    const value = record[key];
-    if (value === undefined && !required)
-        return undefined;
-    if (typeof value !== 'string' || value.length < 1 || value.length > maximum) {
-        throw discoveryError(`Hosted discovery candidate.${key} is invalid or exceeds its metadata budget.`);
-    }
-    return value;
-}
-export function validateHostedSkillDiscovery(payload, options) {
-    assertMetadataOnly(payload);
-    const candidate = unwrapData(payload);
-    if (!isRecord(candidate))
-        throw discoveryError('Hosted skill search result must be an object.');
-    const query = boundedString(candidate, 'query', 256);
-    const normalizedQuery = boundedString(candidate, 'normalizedQuery', 256);
-    if (!Array.isArray(candidate.candidates) || candidate.candidates.length > options.limit || candidate.candidates.length > 5) {
-        throw discoveryError('Hosted skill search exceeded the requested candidate limit.', {
-            requestedLimit: options.limit,
-            candidateCount: Array.isArray(candidate.candidates) ? candidate.candidates.length : null,
-        });
-    }
-    if (candidate.count !== candidate.candidates.length) {
-        throw discoveryError('Hosted skill search count does not match its candidate array.');
-    }
-    const candidates = candidate.candidates.map((entry, index) => {
-        if (!isRecord(entry))
-            throw discoveryError(`Hosted skill search candidate ${index} must be an object.`);
-        const versionId = boundedString(entry, 'versionId', 160);
-        const exactRef = boundedString(entry, 'exactRef', 180);
-        const match = EXACT_REF.exec(exactRef);
-        if (!match || match[1] !== versionId) {
-            throw discoveryError(`Hosted skill search candidate ${index} has inconsistent exact identity.`);
-        }
-        if (entry.origin !== 'hosted')
-            throw discoveryError(`Hosted skill search candidate ${index} has an invalid origin.`);
-        const packageSha256 = boundedString(entry, 'packageSha256', 64);
-        const contentSha256 = boundedString(entry, 'contentSha256', 64);
-        if (!SHA256_HEX.test(packageSha256) || !SHA256_HEX.test(contentSha256)) {
-            throw discoveryError(`Hosted skill search candidate ${index} has invalid immutable digest metadata.`);
-        }
-        if (entry.computedTrustClass !== 'verified-hosted-package') {
-            throw discoveryError(`Hosted skill search candidate ${index} has an invalid computed trust class.`);
-        }
-        if (!Number.isSafeInteger(entry.score) || entry.score < 1) {
-            throw discoveryError(`Hosted skill search candidate ${index} has an invalid score.`);
-        }
-        if (!Array.isArray(entry.matchedBy)
-            || entry.matchedBy.length < 1
-            || entry.matchedBy.length > 5
-            || entry.matchedBy.some((field) => typeof field !== 'string' || !MATCH_FIELD.test(field))
-            || new Set(entry.matchedBy).size !== entry.matchedBy.length) {
-            throw discoveryError(`Hosted skill search candidate ${index} has invalid match metadata.`);
-        }
-        return Object.freeze({
-            name: boundedString(entry, 'name', 80),
-            version: boundedString(entry, 'version', 80),
-            versionId,
-            exactRef,
-            packageSha256,
-            contentSha256,
-            ...(entry.shortDescription === undefined
-                ? {}
-                : { shortDescription: boundedString(entry, 'shortDescription', 96, false) }),
-            origin: 'hosted-cache',
-            computedTrustClass: 'verified-hosted-package',
-            score: entry.score,
-            matchedBy: Object.freeze([...entry.matchedBy]),
-            rationale: boundedString(entry, 'rationale', 160),
-        });
-    });
-    return Object.freeze({ query, normalizedQuery, candidates: Object.freeze(candidates) });
-}
-export async function discoverHostedSkills(options) {
-    let payload;
-    try {
-        const input = Object.freeze({ query: options.query, limit: options.limit });
-        if (options.invoke) {
-            payload = await options.invoke('agentspace.skill.search', input);
-        }
-        else {
-            const apiState = await createCliApiClientFromOptions({ apiBaseUrl: options.apiBaseUrl });
-            const response = await invokeHostedToolWithApiState(apiState, {
-                apiBaseUrl: options.apiBaseUrl,
-                toolId: 'agentspace.skill.search',
-                input,
-            });
-            payload = unwrapHostedToolResult(response);
-        }
-    }
-    catch (error) {
-        if (error instanceof AgentAssetsError)
-            throw error;
-        throw new AgentAssetsError('remote_unavailable', 'Hosted skill metadata search failed.', {
-            nextActions: ['Retry when the selected AOPS server is reachable, or use `--offline` for the installed core only.'],
-            cause: error,
-        });
-    }
-    return validateHostedSkillDiscovery(payload, options);
-}

package/dist/lib/agent-assets/hosted-package-input.js

@@ -1,154 +0,0 @@
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
-import { invokeHostedToolWithApiState, unwrapHostedToolResult } from '../../utils/agent-gateway.js';
-import { createCliApiClientFromOptions } from '../../utils/api.js';
-import { AgentAssetsError } from './envelope.js';
-import { validatePortablePackageV1 } from './package-manifest.js';
-import { canonicalJsonV1 } from './store-reader.js';
-const FORBIDDEN_SERVER_PATH_KEYS = new Set([
-    'filesystemPath',
-    'materializedPath',
-    'outputDir',
-    'packagePath',
-    'serverPath',
-    'sourcePath',
-]);
-function packageError(code, message, details) {
-    return new AgentAssetsError(code, message, {
-        nextActions: [
-            'Inspect the exact hosted contract with `aops-cli agent schema --tool agentspace.skill-version.export-skill-package --summary`.',
-        ],
-        ...(details === undefined ? {} : { details }),
-    });
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function unwrapData(value) {
-    let current = value;
-    for (let depth = 0; depth < 3; depth += 1) {
-        if (!isRecord(current) || !Object.prototype.hasOwnProperty.call(current, 'data'))
-            break;
-        current = current.data;
-    }
-    return current;
-}
-function assertNoServerFilesystemPointers(value) {
-    if (!value || typeof value !== 'object')
-        return;
-    for (const [key, child] of Object.entries(value)) {
-        if (FORBIDDEN_SERVER_PATH_KEYS.has(key) && typeof child === 'string' && child.trim()) {
-            throw packageError('untrusted_origin', `Hosted client export leaked a server filesystem field: ${key}.`);
-        }
-        assertNoServerFilesystemPointers(child);
-    }
-}
-function nonEmpty(record, key, label) {
-    const value = record[key];
-    if (typeof value !== 'string' || !value.trim()) {
-        throw packageError('schema_incompatible', `${label}.${key} must be a non-empty string.`);
-    }
-    return value;
-}
-function readExpectedManifest(reference, versionId) {
-    if (!reference.startsWith('@')) {
-        if (reference !== `skill-version:${versionId}`) {
-            throw packageError('expected_manifest_required', 'Expected manifest must be @file.json or the exact immutable skill-version ref.', {
-                expected: `skill-version:${versionId}`,
-            });
-        }
-        return null;
-    }
-    const filePath = path.resolve(reference.slice(1));
-    let raw;
-    try {
-        raw = readFileSync(filePath, 'utf8');
-    }
-    catch (error) {
-        throw packageError('expected_manifest_required', 'Expected manifest file could not be read.', {
-            cause: error instanceof Error ? error.message : String(error),
-        });
-    }
-    if (Buffer.byteLength(raw, 'utf8') > 1024 * 1024) {
-        throw packageError('schema_incompatible', 'Expected manifest exceeds the 1 MiB input limit.');
-    }
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        throw packageError('schema_incompatible', 'Expected manifest is not valid JSON.');
-    }
-}
-export function assertExpectedSkillPackageManifestV1(reference, versionId, manifest) {
-    if (manifest.assetKind !== 'skill-package' ||
-        manifest.versionId !== versionId ||
-        manifest.provenance.reference !== `skill-version:${versionId}`) {
-        throw packageError('untrusted_origin', 'Package manifest does not identify the exact immutable skill version.');
-    }
-    const expectedManifest = readExpectedManifest(reference, versionId);
-    if (expectedManifest !== null && canonicalJsonV1(expectedManifest) !== canonicalJsonV1(manifest)) {
-        throw packageError('hash_mismatch', 'Immutable manifest differs from the caller-pinned expected manifest.');
-    }
-}
-export function validateHostedSkillPackageExport(payload, options) {
-    assertNoServerFilesystemPointers(payload);
-    const candidate = unwrapData(payload);
-    if (!isRecord(candidate))
-        throw packageError('schema_incompatible', 'Hosted export result must be an object.');
-    const skillVersionId = nonEmpty(candidate, 'skillVersionId', 'HostedSkillPackageExport');
-    if (skillVersionId !== options.versionId) {
-        throw packageError('hash_mismatch', 'Hosted export returned a different immutable skill version.');
-    }
-    if (!Array.isArray(candidate.files) || candidate.files.length === 0) {
-        throw packageError('schema_incompatible', 'Hosted export did not include package files.');
-    }
-    const transferFiles = candidate.files.map((file, index) => {
-        if (!isRecord(file) || typeof file.path !== 'string' || typeof file.content !== 'string') {
-            throw packageError('schema_incompatible', `Hosted export file ${index} must contain path and UTF-8 content.`);
-        }
-        return { path: file.path, bytes: Buffer.from(file.content, 'utf8') };
-    });
-    const validation = validatePortablePackageV1(candidate.manifest, transferFiles);
-    if (!validation.ok) {
-        throw packageError('hash_mismatch', 'Hosted package bytes do not match immutable publish-time metadata.', {
-            issues: validation.issues,
-        });
-    }
-    const manifest = validation.value.normalizedManifest;
-    assertExpectedSkillPackageManifestV1(options.expectedManifest, skillVersionId, manifest);
-    return {
-        skillVersionId,
-        skillId: nonEmpty(candidate, 'skillId', 'HostedSkillPackageExport'),
-        skillName: nonEmpty(candidate, 'skillName', 'HostedSkillPackageExport'),
-        projectId: nonEmpty(candidate, 'projectId', 'HostedSkillPackageExport'),
-        scopeId: nonEmpty(candidate, 'scopeId', 'HostedSkillPackageExport'),
-        manifest,
-        transferFiles,
-        validation: validation.value,
-    };
-}
-export async function pullHostedSkillPackage(options) {
-    let payload;
-    try {
-        if (options.invoke) {
-            payload = await options.invoke('agentspace.skill-version.export-skill-package', { id: options.versionId });
-        }
-        else {
-            const apiState = await createCliApiClientFromOptions({ apiBaseUrl: options.apiBaseUrl });
-            const response = await invokeHostedToolWithApiState(apiState, {
-                apiBaseUrl: options.apiBaseUrl,
-                toolId: 'agentspace.skill-version.export-skill-package',
-                input: { id: options.versionId },
-            });
-            payload = unwrapHostedToolResult(response);
-        }
-    }
-    catch (error) {
-        if (error instanceof AgentAssetsError)
-            throw error;
-        throw packageError('remote_unavailable', 'Hosted skill package export failed.', {
-            cause: error instanceof Error ? error.message : String(error),
-        });
-    }
-    return validateHostedSkillPackageExport(payload, options);
-}