evolcore 0.0.1 → 0.0.3

package/dist/core/command/menu-protocol.js

@@ -0,0 +1,247 @@
+import { createHash } from 'crypto';
+export const MENU_REQUEST_TYPES = new Set([
+    'menu.list',
+    'menu.query',
+    'menu.options',
+    'menu.update',
+    'menu.action',
+]);
+const EXPLICIT_SCOPE_UPDATE_NAMES = new Set([
+    'model',
+    'effort',
+    'chatmode',
+    'dispatch',
+    'mentionmode',
+    'permission',
+]);
+const EXPLICIT_SCOPE_UPDATE_COMMANDS = new Set([
+    '/model',
+    '/effort',
+    '/chatmode',
+    '/dispatch',
+    '/mentionmode',
+    '/perm',
+]);
+function firstCommandToken(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    return value.trim().split(/\s+/, 1)[0] || undefined;
+}
+function requiresExplicitConfigWriteScope(nameOrCmd) {
+    const token = firstCommandToken(nameOrCmd);
+    return !!token && (EXPLICIT_SCOPE_UPDATE_NAMES.has(token) || EXPLICIT_SCOPE_UPDATE_COMMANDS.has(token));
+}
+export function validateConfigWriteScope(nameOrCmd, args) {
+    if (!requiresExplicitConfigWriteScope(nameOrCmd))
+        return null;
+    const rawScope = args?.scope;
+    if (rawScope === undefined || rawScope === null || (typeof rawScope === 'string' && rawScope.trim().length === 0)) {
+        return { code: 'MISSING_SCOPE', message: '配置写操作必须显式提供 args.scope' };
+    }
+    if (typeof rawScope !== 'string') {
+        return { code: 'INVALID_SCOPE', message: 'args.scope 必须是 agent 或 relation' };
+    }
+    const scope = rawScope.trim();
+    if (scope !== 'agent' && scope !== 'relation') {
+        return { code: 'INVALID_SCOPE', message: `无效 scope: ${scope}，可选: agent / relation` };
+    }
+    return null;
+}
+export function parseMenuControl(content) {
+    let value;
+    try {
+        value = JSON.parse(content);
+    }
+    catch {
+        return { isMenu: false };
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return { isMenu: false };
+    const request = value;
+    if (typeof request.type !== 'string' || !request.type.startsWith('menu.'))
+        return { isMenu: false };
+    return {
+        isMenu: true,
+        raw: content,
+        request,
+        type: request.type,
+        id: typeof request.id === 'string' ? request.id : undefined,
+        name: typeof request.name === 'string' ? request.name : undefined,
+        action: typeof request.action === 'string' ? request.action : undefined,
+    };
+}
+export function hasValidMenuId(parsed) {
+    return typeof parsed.id === 'string' && parsed.id.trim().length > 0;
+}
+export function validateMenuRequest(request) {
+    const type = request.type;
+    if (!MENU_REQUEST_TYPES.has(type)) {
+        return { code: 'METHOD_NOT_FOUND', message: `Unknown menu request type: ${type}` };
+    }
+    const hasName = typeof request.name === 'string' && request.name.trim().length > 0;
+    const hasCompatCmd = typeof request.cmd === 'string' && request.cmd.trim().length > 0;
+    if (type !== 'menu.list' && !hasName && !hasCompatCmd) {
+        return { code: 'INVALID_ARGUMENT', message: 'Menu request name is required' };
+    }
+    if (request.args !== undefined && (!request.args || typeof request.args !== 'object' || Array.isArray(request.args))) {
+        return { code: 'INVALID_ARGUMENT', message: 'Menu request args must be an object' };
+    }
+    if (type === 'menu.update') {
+        const args = request.args;
+        const scopeError = validateConfigWriteScope(request.name, args)
+            ?? validateConfigWriteScope(request.cmd, args);
+        if (scopeError)
+            return scopeError;
+    }
+    if (type === 'menu.update' && (typeof request.value !== 'string' || request.value.length === 0)) {
+        return { code: 'INVALID_ARGUMENT', message: 'Menu request value is required' };
+    }
+    if (type === 'menu.action' && (typeof request.action !== 'string' || request.action.trim().length === 0)) {
+        return { code: 'INVALID_ARGUMENT', message: 'Menu request action is required' };
+    }
+    if (type === 'menu.action' && request.name === 'cli' && request.action === 'exec') {
+        const args = request.args;
+        const hasArgv = Array.isArray(args?.argv) && args.argv.length > 0;
+        const hasLegacyCommand = typeof args?.command === 'string' && args.command.trim().length > 0;
+        if (!hasArgv && !hasLegacyCommand) {
+            return { code: 'INVALID_ARGUMENT', message: 'CLI exec requires args.argv' };
+        }
+    }
+    if (type === 'menu.action' && request.name === 'file' && request.action === 'fetch') {
+        const args = request.args;
+        if (typeof args?.path !== 'string' || args.path.trim().length === 0) {
+            return { code: 'INVALID_ARGUMENT', message: 'File fetch requires args.path' };
+        }
+    }
+    return null;
+}
+export function menuSuccess(header, data) {
+    return {
+        type: 'menu.response',
+        id: header.id,
+        ...(header.name ? { name: header.name } : {}),
+        data,
+    };
+}
+export function menuFailure(header, error) {
+    return {
+        type: 'menu.response',
+        id: header.id,
+        ...(header.name ? { name: header.name } : {}),
+        error: {
+            code: error.code,
+            message: error.message,
+            ...(error.data !== undefined ? { data: error.data } : {}),
+        },
+    };
+}
+const INVALID_ARGUMENT_CODES = new Set([
+    'ARGUMENT_MISMATCH', 'FILE_TOO_LARGE', 'INVALID_ARGS', 'INVALID_DELEGATION',
+    'INVALID_FIELD', 'INVALID_REVISION', 'INVALID_SCOPE', 'INVALID_TYPE', 'INVALID_VALUE', 'MISSING_AID',
+    'MISSING_ARGV', 'MISSING_BASEAGENT', 'MISSING_CMD', 'MISSING_PEER', 'MISSING_VALUE',
+    'NOT_A_DIRECTORY', 'REVISION_REQUIRED', 'ROLE_VIOLATION',
+]);
+const STABLE_CODES = new Set([
+    'ROLE_ACCESS_DENIED', 'PERMISSION_DENIED', 'UNAUTHORIZED', 'FORBIDDEN',
+    'INVALID_ARGUMENT', 'NOT_ALLOWED', 'NOT_SUPPORTED', 'UNSUPPORTED',
+    'METHOD_NOT_FOUND', 'NOT_FOUND', 'CONFLICT', 'EXECUTION_TIMEOUT',
+    'TEMPORARILY_UNAVAILABLE', 'INTERNAL_ERROR', 'MISSING_SCOPE',
+]);
+export function normalizeMenuError(error) {
+    const source = error && typeof error === 'object' ? error : {};
+    const rawCode = typeof source.code === 'string' ? source.code : 'INTERNAL_ERROR';
+    const message = typeof source.message === 'string'
+        ? source.message
+        : typeof source.error === 'string'
+            ? source.error
+            : error instanceof Error
+                ? error.message
+                : 'Internal server error';
+    let code = rawCode;
+    if (INVALID_ARGUMENT_CODES.has(rawCode))
+        code = 'INVALID_ARGUMENT';
+    else if (rawCode === 'UNKNOWN_NAME' || rawCode === 'NOT_APPLICABLE' || rawCode === 'UNSUPPORTED_FIELD')
+        code = 'NOT_SUPPORTED';
+    else if (rawCode === 'NO_PERMISSION' || rawCode === 'SCOPE_MISMATCH')
+        code = 'PERMISSION_DENIED';
+    else if (rawCode === 'DANGEROUS_NOT_GRANTED')
+        code = 'NOT_ALLOWED';
+    else if (rawCode === 'NO_ACTIVE_SESSION' || rawCode === 'NO_ACTIVE_TASK' || rawCode === 'INVALID_SESSION')
+        code = 'NOT_FOUND';
+    else if (rawCode === 'BUSY' || rawCode === 'INVALID_STATE' || rawCode === 'DELEGATION_REQUIRED' || rawCode === 'REVISION_CONFLICT')
+        code = 'CONFLICT';
+    else if (rawCode === 'TIMEOUT')
+        code = 'EXECUTION_TIMEOUT';
+    else if (rawCode === 'EXEC_FAILED' || rawCode === 'DELETE_FAILED' || rawCode === 'INTERNAL')
+        code = 'INTERNAL_ERROR';
+    else if (!STABLE_CODES.has(rawCode))
+        code = 'INTERNAL_ERROR';
+    return {
+        code,
+        message,
+        ...(source.data !== undefined ? { data: source.data } : {}),
+    };
+}
+export function menuPayloadFingerprint(raw) {
+    return createHash('sha256').update(raw).digest('hex');
+}
+export class MenuRequestDeduper {
+    ttlMs;
+    maxEntries;
+    entries = new Map();
+    constructor(ttlMs = 30_000, maxEntries = 2_048) {
+        this.ttlMs = ttlMs;
+        this.maxEntries = maxEntries;
+    }
+    async execute(key, fingerprint, operation) {
+        this.prune();
+        const existing = this.entries.get(key);
+        if (existing) {
+            if (existing.fingerprint !== fingerprint)
+                return { conflict: true };
+            return { value: await existing.promise, replayed: true };
+        }
+        const promise = operation();
+        const entry = { fingerprint, promise, expiresAt: Date.now() + this.ttlMs };
+        this.entries.set(key, entry);
+        this.enforceLimit();
+        try {
+            const value = await promise;
+            entry.expiresAt = Date.now() + this.ttlMs;
+            return { value, replayed: false };
+        }
+        catch (error) {
+            this.entries.delete(key);
+            throw error;
+        }
+    }
+    prune() {
+        const now = Date.now();
+        for (const [key, entry] of this.entries) {
+            if (entry.expiresAt <= now)
+                this.entries.delete(key);
+        }
+    }
+    enforceLimit() {
+        while (this.entries.size > this.maxEntries) {
+            const oldest = this.entries.keys().next().value;
+            if (!oldest)
+                break;
+            this.entries.delete(oldest);
+        }
+    }
+}
+export class MenuDiagnosticLimiter {
+    last = new Map();
+    check(key, intervalMs = 60_000) {
+        const now = Date.now();
+        const previous = this.last.get(key);
+        if (!previous || now - previous.at >= intervalMs) {
+            const suppressed = previous?.suppressed ?? 0;
+            this.last.set(key, { at: now, suppressed: 0 });
+            return { log: true, suppressed };
+        }
+        previous.suppressed += 1;
+        return { log: false, suppressed: previous.suppressed };
+    }
+}