@easyai-canvas/canvas-plugin-sdk 0.1.0

package/dist/protocol/index.js

@@ -0,0 +1,454 @@
+/** Public, dependency-free contract. Host copies are generated by protocol:sync. */
+export const PROTOCOL = 'easyai.plugin/v1';
+function cloneDeclaration(value) {
+    if (Array.isArray(value))
+        return value.map(item => cloneDeclaration(item));
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, cloneDeclaration(item)]));
+    return value;
+}
+export class ContractError extends Error {
+    status;
+    code;
+    constructor(message, status = 400, code = 'INVALID_REQUEST') {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = 'ContractError';
+    }
+}
+export function object(value, path = 'data') {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new ContractError(`${path} 必须是对象`);
+    return value;
+}
+function keys(value, allowed, path) {
+    const result = object(value, path);
+    for (const key of Object.keys(result))
+        if (!allowed.includes(key))
+            throw new ContractError(`${path}.${key} 不支持`);
+    return result;
+}
+function optionalString(value, path) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || !value.trim())
+        throw new ContractError(`${path} 无效`);
+    return value;
+}
+export function validatePluginRuntimeContext(value) {
+    const context = keys(value, ['user', 'projectId', 'nodeId', 'environment'], 'context');
+    const user = keys(context.user, ['id', 'username', 'ssoId', 'tenantId'], 'context.user');
+    const id = optionalString(user.id, 'context.user.id');
+    if (!id)
+        throw new ContractError('调用身份缺失');
+    if (!['canvas'].includes(String(context.environment)))
+        throw new ContractError('运行环境无效');
+    optionalString(user.username, 'context.user.username');
+    optionalString(user.ssoId, 'context.user.ssoId');
+    optionalString(user.tenantId, 'context.user.tenantId');
+    optionalString(context.projectId, 'context.projectId');
+    optionalString(context.nodeId, 'context.nodeId');
+    return cloneDeclaration(context);
+}
+function validateMenu(value, path) {
+    if (value === undefined)
+        return;
+    const menu = keys(value, ['group', 'order', 'icon'], path);
+    if (!['basic', 'storyboard', 'tools', 'resources'].includes(String(menu.group)))
+        throw new ContractError(`${path} 菜单分组无效`);
+    if (menu.order !== undefined && (typeof menu.order !== 'number' || !Number.isFinite(menu.order)))
+        throw new ContractError(`${path} 菜单顺序无效`);
+    if (menu.icon !== undefined && typeof menu.icon !== 'string')
+        throw new ContractError(`${path} 菜单图标无效`);
+}
+function optionalBoolean(value, path) {
+    if (value !== undefined && typeof value !== 'boolean')
+        throw new ContractError(`${path} 必须是布尔值`);
+}
+function boundedInteger(value, path, min, max) {
+    if (value !== undefined && (typeof value !== 'number' || !Number.isInteger(value) || value < min || value > max))
+        throw new ContractError(`${path} 范围无效`);
+}
+function validateNodeCapabilities(value) {
+    if (value === undefined)
+        return;
+    const capabilities = keys(value, ['documentState', 'workspace', 'mediaUpload', 'inputManagement', 'outputToCanvas'], 'node.capabilities');
+    for (const key of ['workspace', 'mediaUpload', 'inputManagement', 'outputToCanvas'])
+        optionalBoolean(capabilities[key], `node.capabilities.${key}`);
+    if (capabilities.documentState !== undefined) {
+        const document = keys(capabilities.documentState, ['key', 'schema', 'maxBytes', 'renderedRevisionKey', 'resultKey', 'subtitleResultKey'], 'node.capabilities.documentState');
+        identifier(document.key, 'node.capabilities.documentState.key');
+        optionalString(document.schema, 'node.capabilities.documentState.schema');
+        boundedInteger(document.maxBytes, 'node.capabilities.documentState 文档大小', 1_024, 10_000_000);
+        if (document.renderedRevisionKey !== undefined)
+            identifier(document.renderedRevisionKey, 'node.capabilities.documentState.renderedRevisionKey');
+        if (document.resultKey !== undefined)
+            identifier(document.resultKey, 'node.capabilities.documentState.resultKey');
+        if (document.subtitleResultKey !== undefined)
+            identifier(document.subtitleResultKey, 'node.capabilities.documentState.subtitleResultKey');
+    }
+}
+function validateNodeRuntime(value) {
+    if (value === undefined)
+        return;
+    const runtime = keys(value, ['safeRetry', 'maxAttempts', 'maxQueuedPerUser', 'maxQueued'], 'node.runtime');
+    optionalBoolean(runtime.safeRetry, 'node.runtime.safeRetry');
+    boundedInteger(runtime.maxAttempts, 'node.runtime 重试次数', 1, 5);
+    boundedInteger(runtime.maxQueuedPerUser, 'node.runtime 用户排队上限', 1, 100);
+    boundedInteger(runtime.maxQueued, 'node.runtime 全局排队上限', 1, 10_000);
+    if (!runtime.safeRetry && runtime.maxAttempts !== undefined && Number(runtime.maxAttempts) > 1)
+        throw new ContractError('未声明安全重试的节点不能配置多次重试');
+}
+export function identifier(value, path) {
+    if (typeof value !== 'string' || !/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,159}$/.test(value))
+        throw new ContractError(`${path} 标识无效`);
+    return value;
+}
+function validateFields(value) {
+    if (!Array.isArray(value))
+        throw new ContractError('配置字段必须是数组');
+    const seen = new Set();
+    for (const raw of value) {
+        const field = keys(raw, ['key', 'label', 'type', 'default', 'options', 'required'], '配置');
+        const key = identifier(field.key, '配置字段');
+        if (seen.has(key) || ['__proto__', 'constructor', 'prototype'].includes(key))
+            throw new ContractError('配置字段重复或无效');
+        seen.add(key);
+        if (typeof field.label !== 'string' || !['string', 'secret', 'number', 'boolean', 'select'].includes(String(field.type)))
+            throw new ContractError('配置字段类型无效');
+        if (field.required !== undefined && typeof field.required !== 'boolean')
+            throw new ContractError('配置 required 无效');
+        if (field.type === 'select' && (!Array.isArray(field.options) || field.options.some(o => !o || typeof o.value !== 'string' || typeof o.label !== 'string') || new Set(field.options.map(o => o.value)).size !== field.options.length))
+            throw new ContractError('配置选项无效');
+        if (field.default !== undefined)
+            validateParameters([raw], { [key]: field.default });
+    }
+    return value;
+}
+export function validateParameters(fields, input) {
+    const result = { ...input };
+    for (const f of fields) {
+        const value = result[f.key] === undefined ? f.default : result[f.key];
+        if (value === undefined) {
+            if (f.required)
+                throw new ContractError(`缺少参数 ${f.key}`);
+            continue;
+        }
+        if (f.type === 'number' ? typeof value !== 'number' || !Number.isFinite(value) : f.type === 'boolean' ? typeof value !== 'boolean' : typeof value !== 'string')
+            throw new ContractError(`参数 ${f.key} 类型错误`);
+        if (f.type === 'select' && !f.options?.some(o => o.value === value))
+            throw new ContractError(`参数 ${f.key} 选项无效`);
+        result[f.key] = value;
+    }
+    return result;
+}
+/** Returns the interaction-oriented view while preserving legacy asset source manifests. */
+export function listPluginActions(manifest) {
+    const actions = (manifest.contributes.actions ?? []).map(action => cloneDeclaration(action));
+    const ids = new Set(actions.map(action => action.id));
+    for (const source of manifest.contributes.assetSources ?? []) {
+        if (ids.has(source.id))
+            continue;
+        actions.push({
+            id: source.id,
+            name: source.name,
+            ...(source.description ? { description: source.description } : {}),
+            action: 'asset-selection',
+            presentation: 'dialog',
+            mediaTypes: source.mediaTypes.filter((type) => ['image', 'video', 'audio', 'file'].includes(type)),
+            ui: source.ui?.selector
+                ? { component: source.ui.selector }
+                : { url: source.url, origin: source.origin },
+            menu: source.menu ?? { group: 'resources' },
+            legacyAssetSource: true,
+        });
+    }
+    return actions;
+}
+const portTypes = ['text', 'json', 'image', 'video', 'audio', 'file', 'any'];
+export function validateManifest(value) {
+    const root = keys(value, ['protocol', 'id', 'name', 'release', 'configFields', 'contributes'], 'manifest');
+    if (root.protocol !== PROTOCOL)
+        throw new ContractError('插件协议不兼容');
+    identifier(root.id, 'pluginId');
+    if (typeof root.name !== 'string' || !root.name || typeof root.release !== 'string')
+        throw new ContractError('插件名称或发布标识无效');
+    if (root.configFields !== undefined)
+        validateFields(root.configFields);
+    const c = keys(root.contributes, ['nodes', 'actions', 'assetSources'], 'contributes');
+    if (c.nodes !== undefined) {
+        if (!Array.isArray(c.nodes))
+            throw new ContractError('nodes 必须为数组');
+        const names = new Set();
+        for (const raw of c.nodes) {
+            const node = keys(raw, ['type', 'name', 'description', 'inputs', 'outputs', 'parameters', 'execution', 'ui', 'defaults', 'timeoutMs', 'menu', 'capabilities', 'runtime'], 'node');
+            const id = identifier(node.type, 'node.type');
+            if (names.has(id))
+                throw new ContractError('节点标识重复');
+            names.add(id);
+            if (typeof node.name !== 'string' || !['remote', 'source', 'display', 'confirmed'].includes(String(node.execution)))
+                throw new ContractError('节点名称或执行能力无效');
+            if (node.parameters !== undefined)
+                validateFields(node.parameters);
+            validateMenu(node.menu, 'node.menu');
+            validateNodeCapabilities(node.capabilities);
+            validateNodeRuntime(node.runtime);
+            if (node.timeoutMs !== undefined && (typeof node.timeoutMs !== 'number' || !Number.isInteger(node.timeoutMs) || node.timeoutMs < 100 || node.timeoutMs > 3_600_000))
+                throw new ContractError('任务超时范围无效');
+            for (const direction of ['inputs', 'outputs']) {
+                const ports = node[direction];
+                if (!Array.isArray(ports))
+                    throw new ContractError('端口必须为数组');
+                const ids = new Set();
+                for (const p of ports) {
+                    const port = object(p);
+                    const portId = identifier(port.id, 'port.id');
+                    if (ids.has(portId) || !portTypes.includes(port.type))
+                        throw new ContractError('端口标识重复或类型无效');
+                    ids.add(portId);
+                }
+            }
+        }
+    }
+    if (c.actions !== undefined) {
+        if (!Array.isArray(c.actions))
+            throw new ContractError('actions 必须为数组');
+        const actionIds = new Set();
+        for (const raw of c.actions) {
+            const action = keys(raw, ['id', 'name', 'description', 'action', 'presentation', 'mediaTypes', 'maxCount', 'ui', 'menu'], 'action');
+            const actionId = identifier(action.id, 'action.id');
+            if (actionIds.has(actionId))
+                throw new ContractError('操作标识重复');
+            actionIds.add(actionId);
+            if (typeof action.name !== 'string' || !action.name.trim())
+                throw new ContractError('操作名称无效');
+            if (action.action !== 'asset-selection')
+                throw new ContractError('操作类型无效');
+            if (action.presentation !== 'dialog')
+                throw new ContractError('操作展示方式无效');
+            if (!Array.isArray(action.mediaTypes) || !action.mediaTypes.length || action.mediaTypes.some(type => !['image', 'video', 'audio', 'file'].includes(String(type))))
+                throw new ContractError('操作素材类型无效');
+            boundedInteger(action.maxCount, '操作素材数量', 1, 256);
+            validateMenu(action.menu, 'action.menu');
+            const ui = keys(action.ui, ['component', 'url', 'origin'], 'action.ui');
+            const component = optionalString(ui.component, 'action.ui.component');
+            if (component)
+                identifier(component, 'action.ui.component');
+            if (!component && ui.url === undefined)
+                throw new ContractError('操作必须提供界面入口');
+            if (component && (ui.url !== undefined || ui.origin !== undefined))
+                throw new ContractError('操作界面入口不能同时使用组件和 iframe');
+            if (ui.url !== undefined) {
+                let url;
+                try {
+                    url = new URL(String(ui.url));
+                }
+                catch {
+                    throw new ContractError('操作界面地址无效');
+                }
+                if (!['https:', 'http:'].includes(url.protocol) || url.origin !== ui.origin || url.username || url.password)
+                    throw new ContractError('操作界面地址无效');
+            }
+        }
+    }
+    if (c.assetSources !== undefined) {
+        if (!Array.isArray(c.assetSources))
+            throw new ContractError('assetSources 必须为数组');
+        const sourceIds = new Set();
+        for (const raw of c.assetSources) {
+            const source = object(raw, 'assetSource');
+            if (sourceIds.has(String(source.id)))
+                throw new ContractError('素材来源标识重复');
+            sourceIds.add(String(source.id));
+            if (typeof source.name !== 'string' || !Array.isArray(source.mediaTypes) || !source.mediaTypes.length || source.mediaTypes.some(t => !['image', 'video', 'audio', 'file'].includes(t)))
+                throw new ContractError('素材来源类型无效');
+            identifier(source.id, 'source.id');
+            validateMenu(source.menu, 'assetSource.menu');
+            const ui = source.ui === undefined ? undefined : keys(source.ui, ['selector'], 'assetSource.ui');
+            if (ui)
+                identifier(ui.selector, 'assetSource.ui.selector');
+            if (source.url === undefined && !ui)
+                throw new ContractError('素材来源必须提供地址或组件');
+            if (source.url !== undefined) {
+                let url;
+                try {
+                    url = new URL(String(source.url));
+                }
+                catch {
+                    throw new ContractError('素材选择器地址无效');
+                }
+                if (!['https:', 'http:'].includes(url.protocol) || url.origin !== source.origin || url.username || url.password)
+                    throw new ContractError('素材选择器地址无效');
+            }
+        }
+    }
+    return cloneDeclaration(root);
+}
+export function validatePacket(value, expected = 'any') {
+    const packet = object(value, 'packet');
+    if (!portTypes.includes(packet.type) || (expected !== 'any' && packet.type !== expected))
+        throw new ContractError('数据类型与端口不匹配');
+    const payload = object(packet.payload, 'payload');
+    if (packet.type === 'json') {
+        if (payload.data === undefined)
+            throw new ContractError('JSON 数据缺失');
+    }
+    else {
+        if (!Array.isArray(payload.items) || payload.items.length > 256)
+            throw new ContractError('数据项无效或过多');
+        for (const raw of payload.items) {
+            const item = object(raw, 'payload.items');
+            if (packet.type === 'text') {
+                if (typeof item.content !== 'string')
+                    throw new ContractError('文本内容无效');
+            }
+            else {
+                let url;
+                try {
+                    url = new URL(String(item.url));
+                }
+                catch {
+                    throw new ContractError('资源地址无效');
+                }
+                if (!['https:', 'http:'].includes(url.protocol) || url.username || url.password)
+                    throw new ContractError('资源地址无效');
+            }
+        }
+    }
+    return packet;
+}
+export function validateExecution(value, node) {
+    const request = keys(value, ['executionId', 'pluginId', 'nodeType', 'parameters', 'inputsByPort', 'document', 'context', 'host'], 'execution');
+    identifier(request.executionId, 'executionId');
+    identifier(request.pluginId, 'pluginId');
+    if (request.nodeType !== node.type)
+        throw new ContractError('节点类型不匹配');
+    object(request.parameters, 'parameters');
+    const context = object(request.context, 'context');
+    identifier(context.nodeId, 'nodeId');
+    if (typeof context.userId !== 'string' || !context.userId)
+        throw new ContractError('调用身份缺失');
+    if (context.runtime !== undefined)
+        validatePluginRuntimeContext(context.runtime);
+    if (request.host !== undefined) {
+        const host = keys(request.host, ['files'], 'execution.host');
+        if (host.files !== undefined) {
+            const files = keys(host.files, ['baseUrl', 'grant', 'expiresAt', 'path'], 'execution.host.files');
+            let url;
+            try {
+                url = new URL(String(files.baseUrl));
+            }
+            catch {
+                throw new ContractError('宿主文件能力地址无效');
+            }
+            const loopbackHttp = url.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]', '::1'].includes(url.hostname);
+            if ((url.protocol !== 'https:' && !loopbackHttp) || url.username || url.password || url.search || url.hash)
+                throw new ContractError('宿主文件能力地址必须是 HTTPS 或本机回环地址');
+            if (files.path !== undefined && !['/v1/plugin-artifacts'].includes(String(files.path)))
+                throw new ContractError('宿主文件能力路径无效');
+            if (typeof files.grant !== 'string' || !files.grant || files.grant.length > 8_192)
+                throw new ContractError('宿主文件能力授权无效');
+            const now = Date.now();
+            if (!Number.isSafeInteger(files.expiresAt) || Number(files.expiresAt) <= now || Number(files.expiresAt) > now + 2 * 60 * 60 * 1_000)
+                throw new ContractError('宿主文件能力授权有效期无效');
+        }
+    }
+    if (request.document !== undefined) {
+        if (!node.capabilities?.documentState)
+            throw new ContractError('节点不接受文档快照');
+        const document = keys(request.document, ['key', 'schema', 'revision', 'value'], 'document');
+        if (document.key !== node.capabilities.documentState.key)
+            throw new ContractError('文档状态字段不匹配');
+        if (node.capabilities.documentState.schema && document.schema !== node.capabilities.documentState.schema)
+            throw new ContractError('文档格式不匹配');
+        optionalString(document.revision, 'document.revision');
+        const bytes = new TextEncoder().encode(JSON.stringify(document.value)).byteLength;
+        if (bytes > (node.capabilities.documentState.maxBytes ?? 1_000_000))
+            throw new ContractError('文档快照超过大小限制');
+    }
+    const inputs = object(request.inputsByPort, 'inputsByPort');
+    for (const id of Object.keys(inputs))
+        if (!node.inputs.some(p => p.id === id))
+            throw new ContractError(`未知输入端口 ${id}`);
+    for (const port of node.inputs) {
+        const packets = inputs[port.id] ?? [];
+        if (!Array.isArray(packets) || (port.required && packets.length === 0) || (!port.multiple && packets.length > 1))
+            throw new ContractError(`输入端口 ${port.id} 数量不符`);
+        packets.forEach(packet => validatePacket(packet, port.type));
+        const count = packets.reduce((total, packet) => total + (Array.isArray(packet.payload.items) ? packet.payload.items.length : 1), 0);
+        if ((!port.multiple && count > 1) || (port.required && count === 0))
+            throw new ContractError(`输入端口 ${port.id} 数据项数量不符`);
+    }
+    return request;
+}
+export function validateResult(value, node) {
+    const root = keys(value, ['outputs', 'parameters', 'documentRevision', 'phase'], 'result');
+    const outputs = object(root.outputs, 'outputs');
+    for (const id of Object.keys(outputs)) {
+        const port = node.outputs.find(p => p.id === id);
+        if (!port)
+            throw new ContractError(`未知输出端口 ${id}`);
+        validatePacket(outputs[id], port.type);
+    }
+    for (const port of node.outputs)
+        if (port.required !== false && outputs[port.id] === undefined)
+            throw new ContractError(`缺少输出端口 ${port.id}`);
+    optionalString(root.documentRevision, 'result.documentRevision');
+    optionalString(root.phase, 'result.phase');
+    return root;
+}
+export function validateSelectedResources(resources, allowedTypes, limit) {
+    if (!Array.isArray(resources) || resources.length > limit)
+        throw new ContractError('素材数量超过限制');
+    return resources.map(raw => {
+        const item = object(raw);
+        if (!allowedTypes.includes(String(item.type)))
+            throw new ContractError('素材类型不符合当前字段要求');
+        validatePacket({ type: item.type, payload: { items: [item] } });
+        for (const key of ['width', 'height', 'size', 'duration'])
+            if (item[key] !== undefined && (typeof item[key] !== 'number' || !Number.isFinite(item[key]) || Number(item[key]) < 0))
+                throw new ContractError('素材信息无效');
+        return cloneDeclaration(item);
+    });
+}
+/** One outstanding iframe selection. A caller must cancel on close/unmount. */
+export class AssetSelectionSession {
+    requestId;
+    origin;
+    source;
+    allowedTypes;
+    limit;
+    closed = false;
+    constructor(requestId, origin, source, allowedTypes, limit) {
+        this.requestId = requestId;
+        this.origin = origin;
+        this.source = source;
+        this.allowedTypes = allowedTypes;
+        this.limit = limit;
+    }
+    cancel() { this.closed = true; }
+    receive(event) {
+        if (this.closed || event.origin !== this.origin || event.source !== this.source)
+            return;
+        const message = object(event.data);
+        if (message.requestId !== this.requestId)
+            return;
+        if (message.type === 'easyai.assets.cancelled') {
+            this.cancel();
+            return [];
+        }
+        if (message.type !== 'easyai.assets.selected')
+            return;
+        const result = validateSelectedResources(message.resources, this.allowedTypes, this.limit);
+        this.closed = true;
+        return result;
+    }
+}
+/** Confirmation binds semantic input content, not transport timestamps or object key order. */
+export function confirmationPayload(parameters, inputs) {
+    const stable = (value) => Array.isArray(value) ? value.map(stable)
+        : value && typeof value === 'object' ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, stable(item)])) : value;
+    const packets = Object.fromEntries(Object.entries(inputs).map(([port, values]) => [port, values.map(({ type, payload, source }) => ({ type, payload, ...(source ? { source: { nodeId: source.nodeId, portId: source.portId } } : {}) }))]));
+    return JSON.stringify(stable({ parameters, inputs: packets }));
+}

package/dist/runtime/auth.d.ts

@@ -0,0 +1 @@
+export declare function authenticate(header: string | undefined, admin?: boolean): Promise<void>;

package/dist/runtime/auth.js

@@ -0,0 +1,68 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+function fail(message) { throw new Error(message); }
+function decodePart(value) {
+    try {
+        return JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
+    }
+    catch {
+        return fail('调用凭证格式无效');
+    }
+}
+function verifyToken(token) {
+    if (token.length > 8_192)
+        fail('调用凭证格式无效');
+    const [encodedHeader, encodedClaims, signature, extra] = token.split('.');
+    if (!encodedHeader || !encodedClaims || !signature || extra)
+        fail('调用凭证格式无效');
+    const header = decodePart(encodedHeader);
+    if (header.alg !== 'HS256' || header.typ !== 'JWT')
+        fail('调用凭证算法无效');
+    const secret = process.env.PLUGIN_SERVICE_SIGNING_SECRET ?? '';
+    if (Buffer.byteLength(secret) < 32)
+        fail('插件服务调用凭证未配置');
+    const expected = createHmac('sha256', secret).update(`${encodedHeader}.${encodedClaims}`).digest();
+    let actual;
+    try {
+        actual = Buffer.from(signature, 'base64url');
+    }
+    catch {
+        return fail('调用凭证签名无效');
+    }
+    if (actual.length !== expected.length || !timingSafeEqual(actual, expected))
+        fail('调用凭证签名无效');
+    const claims = decodePart(encodedClaims);
+    const now = Math.floor(Date.now() / 1000);
+    if (claims.iss !== (process.env.PLUGIN_SERVICE_ISSUER ?? 'easyai-main'))
+        fail('调用凭证签发方无效');
+    if (claims.aud !== (process.env.PLUGIN_SERVICE_AUDIENCE ?? 'easyai-plugin-service'))
+        fail('调用凭证接收方无效');
+    if (!claims.sub || typeof claims.sub !== 'string')
+        fail('调用凭证主体无效');
+    if (!Number.isSafeInteger(claims.iat) || !Number.isSafeInteger(claims.exp))
+        fail('调用凭证时间无效');
+    if (claims.exp <= now - 5)
+        fail('调用凭证已过期');
+    if (claims.iat > now + 30 || claims.exp - claims.iat > 300)
+        fail('调用凭证有效期无效');
+    if (!Array.isArray(claims.scope) || !claims.scope.every(scope => typeof scope === 'string'))
+        fail('调用凭证权限无效');
+    return claims;
+}
+export async function authenticate(header, admin = false) {
+    const mode = process.env.PLUGIN_AUTH_MODE ?? (process.env.NODE_ENV === 'production' ? 'token' : 'local');
+    if (mode === 'local') {
+        if (process.env.NODE_ENV === 'production')
+            fail('生产环境不能使用本地认证模式');
+        return;
+    }
+    if (mode !== 'token')
+        fail('插件服务认证模式无效');
+    const match = /^Bearer ([A-Za-z0-9_.-]+)$/.exec(header ?? '');
+    if (!match)
+        fail('缺少调用凭证');
+    const claims = verifyToken(match[1]);
+    if (!claims.scope.includes('invoke'))
+        fail('调用凭证缺少执行权限');
+    if (admin && !claims.scope.includes('admin'))
+        fail('调用凭证缺少管理权限');
+}

package/dist/runtime/engine.d.ts

@@ -0,0 +1,49 @@
+import { RuntimeStore } from './store.js';
+import type { Plugin } from '../sdk/index.js';
+import { type Catalog, type ExecutionRequest, type PluginRuntimeContext } from '../protocol/index.js';
+export declare class Runtime {
+    private readonly presentations;
+    private readonly executionEntries;
+    readonly store: RuntimeStore;
+    readonly plugins: Plugin[];
+    private queue;
+    private active;
+    /** Task grants stay in memory only. They are deliberately excluded from SQLite records and snapshots. */
+    private hostFiles;
+    private draining;
+    private readonly releaseInstanceLock;
+    constructor(path: string, plugins?: Plugin[], presentations?: Record<string, Record<string, unknown>>, executionEntries?: Record<string, {
+        entry: string;
+        digest: string;
+        entryHash: string;
+    }>);
+    plugin(id: string): Plugin;
+    configure(id: string, patch: {
+        enabled?: boolean;
+        config?: Record<string, unknown>;
+        expectedVersion?: number;
+    }): import("../protocol/index.js").CatalogEntry;
+    catalog(): Catalog;
+    checkConfig(id: string): Promise<{
+        supported: boolean;
+        validation: string;
+        message: string;
+        result?: undefined;
+    } | {
+        supported: boolean;
+        validation: string;
+        result: unknown;
+        message?: undefined;
+    }>;
+    query(id: string, name: string, input: Record<string, unknown>, context: PluginRuntimeContext, signal?: AbortSignal): Promise<unknown>;
+    normalize(id: string, nodeType: string, parameters: Record<string, unknown>): Record<string, unknown>;
+    submit(request: ExecutionRequest): {
+        created: boolean;
+        record: import("../protocol/index.js").ExecutionRecord;
+    };
+    private enqueue;
+    cancel(id: string): import("../protocol/index.js").ExecutionRecord;
+    private pump;
+    private killWorker;
+    close(): Promise<void>;
+}