@minionry/app-manifest 0.1.14

package/LICENSE

@@ -0,0 +1,14 @@
+Minionry Commercial License
+
+Copyright (c) 2025-present Minionry, Inc. All rights reserved.
+
+This software is not open-source. It is provided under a commercial
+license, and your rights to install, use, and (where the Minionry Terms
+of Service expressly permit it) distribute this software are set out
+there, together with all applicable restrictions, termination, and
+disclaimer terms:
+
+https://app.minionry.com/terms
+
+If you do not agree to the Minionry Terms of Service, you may not
+install or use this software.

package/README.md

@@ -0,0 +1,8 @@
+# @minionry/app-manifest
+
+Types, validation, and hashing for Minionry app manifests.
+
+For use with Minionry (https://minionry.com).
+
+Proprietary. © Minionry, Inc. All rights reserved. Use is subject to the terms
+in LICENSE.

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+export declare const SDK_VERSION = 1;
+export declare const MANIFEST_PATH = "/.well-known/minionry.json";
+export type Scope = 'identity' | 'storage' | 'files:app' | 'pm:read' | 'agents:run' | 'pm:write' | 'files:workspace:read' | 'files:workspace:write' | 'pm:execute' | 'pm:schedule' | 'agents:sessions' | 'browser:read' | 'browser:control' | 'settings:read' | 'notifications' | 'git:read' | 'git:write' | 'git:remote' | 'terminal:read' | 'terminal:exec' | 'tools:serve' | 'quality:read' | 'quality:run' | 'inference:run' | 'endpoints:register';
+export declare const SCOPES: readonly Scope[];
+export type RiskTier = 'low' | 'medium' | 'high' | 'critical';
+export declare const RISK_TIERS: readonly RiskTier[];
+export declare const SCOPE_RISK: Record<Scope, RiskTier>;
+export declare function isScope(value: unknown): value is Scope;
+export type ManifestPermission = 'microphone' | 'camera';
+export declare const MANIFEST_PERMISSIONS: readonly ManifestPermission[];
+export declare function isManifestPermission(value: unknown): value is ManifestPermission;
+export interface AppManifest {
+    name: string;
+    entry: string;
+    scopes: Scope[];
+    sdkVersion: number;
+    icon?: string;
+    description?: string;
+    optionalScopes?: Scope[];
+    permissions?: ManifestPermission[];
+}
+export type ManifestValidationResult = {
+    ok: true;
+    manifest: AppManifest;
+} | {
+    ok: false;
+    errors: string[];
+};
+export declare function validateManifest(value: unknown): ManifestValidationResult;
+export declare function canonicalJson(value: unknown): string;
+export type Sha256Hex = (input: string) => string | Promise<string>;
+export declare function manifestHash(manifest: unknown, sha256Hex: Sha256Hex): Promise<string>;
+export declare function slugifyAppName(name: string): string;
+export declare function deriveAppId(name: string, origin: string, sha256Hex: Sha256Hex): Promise<string>;

package/dist/index.js

@@ -0,0 +1,256 @@
+export const SDK_VERSION = 1;
+export const MANIFEST_PATH = '/.well-known/minionry.json';
+export const SCOPES = [
+    'identity',
+    'storage',
+    'files:app',
+    'pm:read',
+    'agents:run',
+    'pm:write',
+    'files:workspace:read',
+    'files:workspace:write',
+    'pm:execute',
+    'pm:schedule',
+    'agents:sessions',
+    'browser:read',
+    'browser:control',
+    'settings:read',
+    'notifications',
+    'git:read',
+    'git:write',
+    'git:remote',
+    'terminal:read',
+    'terminal:exec',
+    'tools:serve',
+    'quality:read',
+    'quality:run',
+    'inference:run',
+    'endpoints:register',
+];
+export const RISK_TIERS = ['low', 'medium', 'high', 'critical'];
+export const SCOPE_RISK = {
+    identity: 'low',
+    storage: 'low',
+    'files:app': 'low',
+    'pm:read': 'medium',
+    'agents:run': 'high',
+    'pm:write': 'high',
+    'files:workspace:read': 'high',
+    'files:workspace:write': 'critical',
+    'pm:execute': 'critical',
+    'pm:schedule': 'critical',
+    'agents:sessions': 'high',
+    'browser:read': 'high',
+    'browser:control': 'critical',
+    'settings:read': 'low',
+    notifications: 'medium',
+    'git:read': 'medium',
+    'git:write': 'high',
+    'git:remote': 'critical',
+    'terminal:read': 'high',
+    'terminal:exec': 'critical',
+    'tools:serve': 'medium',
+    'quality:read': 'low',
+    'quality:run': 'high',
+    'inference:run': 'high',
+    'endpoints:register': 'high',
+};
+const SCOPE_SET = new Set(SCOPES);
+export function isScope(value) {
+    return typeof value === 'string' && SCOPE_SET.has(value);
+}
+export const MANIFEST_PERMISSIONS = ['microphone', 'camera'];
+const MANIFEST_PERMISSION_SET = new Set(MANIFEST_PERMISSIONS);
+export function isManifestPermission(value) {
+    return typeof value === 'string' && MANIFEST_PERMISSION_SET.has(value);
+}
+export function validateManifest(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return { ok: false, errors: [`manifest: must be a JSON object (got ${describeType(value)})`] };
+    }
+    const raw = value;
+    const errors = [];
+    const name = requireNonEmptyString(raw, 'name', errors);
+    const entry = requireNonEmptyString(raw, 'entry', errors);
+    let sdkVersion = null;
+    if (raw.sdkVersion === undefined) {
+        errors.push('sdkVersion: required field is missing');
+    }
+    else if (typeof raw.sdkVersion !== 'number' ||
+        !Number.isInteger(raw.sdkVersion) ||
+        raw.sdkVersion < 1) {
+        errors.push(`sdkVersion: must be a positive integer (got ${formatValue(raw.sdkVersion)})`);
+    }
+    else {
+        sdkVersion = raw.sdkVersion;
+    }
+    let scopes = null;
+    if (raw.scopes === undefined) {
+        errors.push('scopes: required field is missing');
+    }
+    else {
+        scopes = readScopeList(raw.scopes, 'scopes', errors);
+    }
+    let optionalScopes = null;
+    if (raw.optionalScopes !== undefined) {
+        optionalScopes = readScopeList(raw.optionalScopes, 'optionalScopes', errors);
+    }
+    if (scopes !== null && optionalScopes !== null) {
+        const declared = new Set(scopes);
+        for (const scope of optionalScopes) {
+            if (declared.has(scope)) {
+                errors.push(`optionalScopes: scope '${scope}' is already declared in scopes`);
+            }
+        }
+    }
+    let permissions = null;
+    if (raw.permissions !== undefined) {
+        permissions = readPermissionList(raw.permissions, 'permissions', errors);
+    }
+    const icon = optionalString(raw, 'icon', errors);
+    const description = optionalString(raw, 'description', errors);
+    if (errors.length > 0 || name === null || entry === null || scopes === null || sdkVersion === null) {
+        return { ok: false, errors };
+    }
+    const manifest = { name, entry, scopes, sdkVersion };
+    if (icon !== undefined)
+        manifest.icon = icon;
+    if (description !== undefined)
+        manifest.description = description;
+    if (optionalScopes !== null)
+        manifest.optionalScopes = optionalScopes;
+    if (permissions !== null)
+        manifest.permissions = permissions;
+    return { ok: true, manifest };
+}
+function requireNonEmptyString(raw, field, errors) {
+    const value = raw[field];
+    if (value === undefined) {
+        errors.push(`${field}: required field is missing`);
+        return null;
+    }
+    if (typeof value !== 'string') {
+        errors.push(`${field}: must be a string (got ${describeType(value)})`);
+        return null;
+    }
+    if (value.trim() === '') {
+        errors.push(`${field}: must be a non-empty string`);
+        return null;
+    }
+    return value;
+}
+function optionalString(raw, field, errors) {
+    const value = raw[field];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string') {
+        errors.push(`${field}: must be a string (got ${describeType(value)})`);
+        return undefined;
+    }
+    return value;
+}
+function readScopeList(value, field, errors) {
+    if (!Array.isArray(value)) {
+        errors.push(`${field}: must be an array of scope strings (got ${describeType(value)})`);
+        return null;
+    }
+    const seen = new Set();
+    const scopes = [];
+    let valid = true;
+    value.forEach((entry, index) => {
+        if (typeof entry !== 'string') {
+            errors.push(`${field}[${index}]: must be a string (got ${describeType(entry)})`);
+            valid = false;
+        }
+        else if (!isScope(entry)) {
+            errors.push(`${field}[${index}]: unknown scope '${entry}' (valid scopes: ${SCOPES.join(', ')})`);
+            valid = false;
+        }
+        else if (seen.has(entry)) {
+            errors.push(`${field}[${index}]: duplicate scope '${entry}'`);
+            valid = false;
+        }
+        else {
+            seen.add(entry);
+            scopes.push(entry);
+        }
+    });
+    return valid ? scopes : null;
+}
+function readPermissionList(value, field, errors) {
+    if (!Array.isArray(value)) {
+        errors.push(`${field}: must be an array of permission strings (got ${describeType(value)})`);
+        return null;
+    }
+    const seen = new Set();
+    const permissions = [];
+    let valid = true;
+    value.forEach((entry, index) => {
+        if (typeof entry !== 'string') {
+            errors.push(`${field}[${index}]: must be a string (got ${describeType(entry)})`);
+            valid = false;
+        }
+        else if (!isManifestPermission(entry)) {
+            errors.push(`${field}[${index}]: unknown permission '${entry}' (valid permissions: ${MANIFEST_PERMISSIONS.join(', ')})`);
+            valid = false;
+        }
+        else if (seen.has(entry)) {
+            errors.push(`${field}[${index}]: duplicate permission '${entry}'`);
+            valid = false;
+        }
+        else {
+            seen.add(entry);
+            permissions.push(entry);
+        }
+    });
+    return valid ? permissions : null;
+}
+function describeType(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}
+function formatValue(value) {
+    if (typeof value === 'number')
+        return String(value);
+    if (typeof value === 'string')
+        return JSON.stringify(value);
+    return describeType(value);
+}
+export function canonicalJson(value) {
+    return JSON.stringify(sortKeysDeep(value));
+}
+function sortKeysDeep(value) {
+    if (Array.isArray(value))
+        return value.map(sortKeysDeep);
+    if (value !== null && typeof value === 'object') {
+        const source = value;
+        const sorted = {};
+        for (const key of Object.keys(source).sort()) {
+            sorted[key] = sortKeysDeep(source[key]);
+        }
+        return sorted;
+    }
+    return value;
+}
+export async function manifestHash(manifest, sha256Hex) {
+    return (await sha256Hex(canonicalJson(manifest))).toLowerCase();
+}
+export function slugifyAppName(name) {
+    const slug = name
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 48)
+        .replace(/-+$/, '');
+    return slug === '' ? 'app' : slug;
+}
+export async function deriveAppId(name, origin, sha256Hex) {
+    const normalizedOrigin = new URL(origin).origin;
+    const originHash = (await sha256Hex(normalizedOrigin)).toLowerCase().slice(0, 12);
+    return `${slugifyAppName(name)}-${originHash}`;
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@minionry/app-manifest",
+  "version": "0.1.14",
+  "description": "Types, validation, and hashing for Minionry app manifests.",
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "gitHead": "b790f8b643da7b63c57bf12e804dd4a0eba7f312"
+}