evolcore 0.0.3 → 0.0.5

package/dist/core/command/evol-menu-version-gate.js

@@ -0,0 +1,38 @@
+import { loadDaemonConfig } from '../../config-store.js';
+import { readInstalledEvolcoreVersion } from '../../utils/evolcore-version.js';
+import { compareStableSemver, parseStableSemver } from '../../utils/stable-semver.js';
+export function evaluateEvolMenuVersionGate(input) {
+    const minimum = loadDaemonConfig().aun?.minEvolVersion;
+    if (!minimum)
+        return null;
+    const minimumVersion = parseStableSemver(minimum);
+    if (!minimumVersion) {
+        throw new Error('daemon.json.aun.minEvolVersion must use stable X.Y.Z format');
+    }
+    const received = input.protectedHeaders?.evol_version;
+    const receivedVersion = input.encrypted ? parseStableSemver(received) : null;
+    if (!receivedVersion || compareStableSemver(receivedVersion, minimumVersion) < 0) {
+        return {
+            code: 'UPGRADE_REQUIRED',
+            message: `Evol ${minimum} or later is required`,
+            data: {
+                minimum,
+                received: receivedVersion ? received : null,
+            },
+        };
+    }
+    return null;
+}
+export function isEvolMenuVersionGateEnabled() {
+    return loadDaemonConfig().aun?.minEvolVersion !== undefined;
+}
+/** Token may be issued while disabled, but only this flag makes it an access requirement. */
+export function isAunMenuTokenRequired() {
+    return loadDaemonConfig().aun?.menuTokenRequired === true;
+}
+export function evolMenuResponseTransportMetadata(_requestEncrypted) {
+    return {
+        encrypted: true,
+        protectedHeaders: { ec_version: readInstalledEvolcoreVersion() },
+    };
+}

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

@@ -0,0 +1,421 @@
+import crypto from 'crypto';
+import { ConfigTarget, mutateConfig, read as readConfig, resolveEffectiveFieldWithSource, } from '../../config/config-manager.js';
+import { dispatchToMentionMode } from '../../config/mention-mode.js';
+import { readRolesConfig } from '../../config/roles.js';
+import { groupInfo, groupList } from '../../aun/msg/group.js';
+import { formatPeerKey, parsePeerKey } from '../relation/peer-identity.js';
+const DEFAULT_DIRECTORY = {
+    getGroup: groupInfo,
+    listGroups: groupList,
+};
+export class GroupMenuError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = 'GroupMenuError';
+    }
+}
+const SETTINGS = {
+    mentionMode: 'mentionMode',
+    mentionmode: 'mentionMode',
+    rulesPolicy: 'rulesPolicy',
+    rulespolicy: 'rulesPolicy',
+};
+export function groupMenuIntent(kind, args) {
+    if (kind === 'query' && String(args?.view ?? '') === 'list') {
+        return { operation: 'group.list', scope: 'agent' };
+    }
+    const key = settingSelector(kind, args);
+    const scope = settingScope(args);
+    if (key === 'mentionMode') {
+        return { operation: `group.mentionmode.${kind === 'update' ? 'update' : 'current'}`, scope };
+    }
+    return { operation: `group.rulespolicy.${kind === 'update' ? 'update' : 'current'}`, scope };
+}
+/** Adds an explicit relation selector before authorization when a group target was supplied. */
+export function groupMenuAuthorizationArgs(args, receivingSelf, currentPeerKey) {
+    const out = { ...(args ?? {}) };
+    if (receivingSelf && out.self === undefined)
+        out.self = receivingSelf;
+    const rawGroupId = stringArg(out.groupId);
+    if (rawGroupId && out.peer === undefined && out.peerKey === undefined) {
+        out.peer = formatPeerKey('aun', rawGroupId);
+    }
+    else if (!rawGroupId && currentPeerKey && out.peer === undefined && out.peerKey === undefined) {
+        out.peer = currentPeerKey;
+    }
+    return out;
+}
+export async function handleGroupMenu(request, context) {
+    assertSelf(request.args, context.self);
+    if (request.kind === 'query' && String(request.args?.view ?? '') === 'list') {
+        return queryGroupList(context, request.args);
+    }
+    const key = settingSelector(request.kind, request.args);
+    if (request.kind === 'update' && !stringArg(request.args?.scope)) {
+        throw new GroupMenuError('MISSING_SCOPE', 'Group Menu updates require args.scope');
+    }
+    const target = await resolveTarget(request.args, context);
+    if (request.kind === 'options')
+        return settingOptions(key, target);
+    if (request.kind === 'query')
+        return querySetting(key, target);
+    return updateSetting(key, target, request.value, request.args, context);
+}
+function assertSelf(args, self) {
+    const requested = stringArg(args?.self);
+    if (requested && requested !== self) {
+        throw new GroupMenuError('PERMISSION_DENIED', 'args.self does not match the receiving Agent');
+    }
+}
+async function queryGroupList(context, args) {
+    assertAunAvailable(context);
+    const limit = parseLimit(args?.limit);
+    const cursor = optionalString(args?.cursor, 'args.cursor');
+    const result = await groupDirectory(context).listGroups({
+        from: context.self,
+        size: limit,
+        ...(cursor ? { cursor } : {}),
+    });
+    if (!result.ok) {
+        throw new GroupMenuError('TEMPORARILY_UNAVAILABLE', result.error || 'Unable to list joined groups');
+    }
+    const defaultGroupRole = readRolesConfig(context.self).defaultRoles?.group ?? null;
+    const items = result.items.map(group => {
+        const groupId = String(group.group_aid || group.group_id);
+        const peerKey = formatPeerKey('aun', groupId);
+        const relation = readConfig(ConfigTarget.Relation, { self: context.self, peerKey }, { cache: false });
+        const explicitRole = typeof relation?.role === 'string' ? relation.role : null;
+        return {
+            groupId,
+            peerKey,
+            displayName: group.name || groupId,
+            status: group.status,
+            memberCount: group.member_count,
+            roleId: explicitRole,
+            effectiveRoleId: explicitRole ?? defaultGroupRole,
+            effectiveRoleSource: explicitRole ? 'relation' : defaultGroupRole ? 'agent-default' : 'none',
+            relationRevision: relation ? documentRevision(relation) : null,
+        };
+    });
+    return {
+        self: context.self,
+        view: 'list',
+        items,
+        nextCursor: result.nextCursor ?? null,
+        total: result.total,
+        dataSource: {
+            kind: 'aun-live',
+            authoritative: true,
+            complete: !result.nextCursor && items.length >= result.total,
+        },
+    };
+}
+function settingSelector(kind, args) {
+    const parameter = kind === 'query' ? 'view' : kind === 'options' ? 'option' : 'resource';
+    const raw = stringArg(args?.[parameter]);
+    const key = raw ? SETTINGS[raw] : undefined;
+    if (!key) {
+        throw new GroupMenuError('NOT_SUPPORTED', `args.${parameter} must be mentionMode or rulesPolicy`);
+    }
+    return key;
+}
+function settingScope(args) {
+    const raw = stringArg(args?.scope) ?? 'relation';
+    if (raw === 'agent' || raw === 'relation')
+        return raw;
+    throw new GroupMenuError('INVALID_SCOPE', 'args.scope must be agent or relation');
+}
+async function resolveTarget(args, context) {
+    const scope = settingScope(args);
+    if (scope === 'agent')
+        return { scope, selector: { self: context.self } };
+    assertAunAvailable(context);
+    const groupId = groupIdFromArgs(args, context.currentGroupId);
+    const result = await groupDirectory(context).getGroup({
+        from: context.self,
+        groupId,
+        required: ['member', 'state'],
+    });
+    if (!result.ok) {
+        if (result.code === -33001 || result.code === -33006
+            || result.code === '-33001' || result.code === '-33006') {
+            throw new GroupMenuError('NOT_FOUND', 'The target group is not joined by this Agent');
+        }
+        throw new GroupMenuError('TEMPORARILY_UNAVAILABLE', result.error || 'Unable to verify the target group');
+    }
+    const group = result.group;
+    if (!result.found || !group || !group.my_role || group.status === 'dissolved') {
+        throw new GroupMenuError('NOT_FOUND', 'The target group is not joined by this Agent');
+    }
+    const canonicalGroupId = String(group.group_aid || group.group_id || groupId);
+    return {
+        scope,
+        selector: { self: context.self, peerKey: formatPeerKey('aun', canonicalGroupId) },
+        groupId: canonicalGroupId,
+        aunMentionMode: dispatchToMentionMode(group.dispatch_mode
+            ?? group.settings?.dispatch_mode
+            ?? group.metadata?.dispatch_mode),
+    };
+}
+function groupIdFromArgs(args, currentGroupId) {
+    const explicitGroupId = stringArg(args?.groupId);
+    const explicitPeer = stringArg(args?.peerKey) ?? stringArg(args?.peer);
+    let peerGroupId;
+    if (explicitPeer) {
+        try {
+            const parsed = parsePeerKey(explicitPeer);
+            if (parsed.channelType !== 'aun') {
+                throw new GroupMenuError('INVALID_ARGUMENT', 'group settings require an AUN group peerKey');
+            }
+            peerGroupId = parsed.channelId;
+        }
+        catch (error) {
+            if (error instanceof GroupMenuError)
+                throw error;
+            throw new GroupMenuError('INVALID_ARGUMENT', 'args.peerKey must be a valid AUN group peerKey');
+        }
+    }
+    if (explicitGroupId && peerGroupId && explicitGroupId !== peerGroupId) {
+        throw new GroupMenuError('INVALID_ARGUMENT', 'args.groupId and args.peerKey refer to different groups');
+    }
+    const groupId = explicitGroupId ?? peerGroupId ?? currentGroupId;
+    if (!groupId) {
+        throw new GroupMenuError('INVALID_ARGUMENT', 'relation settings require args.groupId or args.peerKey');
+    }
+    return groupId;
+}
+function settingOptions(key, target) {
+    const state = readSettingState(key, target);
+    const values = key === 'mentionMode'
+        ? [
+            { value: 'mention-only', label: '@提及时响应' },
+            { value: 'disabled', label: '所有消息响应' },
+        ]
+        : [
+            { value: 'load', label: '加载群规则' },
+            { value: 'ignore', label: '忽略群规则' },
+        ];
+    return [
+        {
+            value: 'clear',
+            label: key === 'mentionMode' && target.scope === 'agent' ? '使用各群设置' : '使用上级设置',
+            selected: state.override === null,
+            revision: state.revision,
+        },
+        ...values.map(option => ({
+            ...option,
+            selected: state.override === option.value,
+            ...(state.mode ? { effective: state.mode === option.value } : {}),
+            revision: state.revision,
+        })),
+    ];
+}
+function querySetting(key, target) {
+    return settingResponse('view', key, target, readSettingState(key, target));
+}
+function updateSetting(key, target, value, args, context) {
+    const raw = typeof value === 'string' ? value.trim() : '';
+    const allowed = key === 'mentionMode'
+        ? new Set(['mention-only', 'disabled', 'clear'])
+        : new Set(['load', 'ignore', 'clear']);
+    if (!allowed.has(raw)) {
+        throw new GroupMenuError('INVALID_ARGUMENT', `Invalid ${key} value: ${raw || '<empty>'}`);
+    }
+    if (key === 'rulesPolicy' && context.role !== 'owner' && !context.isDaemonOwner) {
+        throw new GroupMenuError('PERMISSION_DENIED', 'rulesPolicy can only be changed by an Agent owner');
+    }
+    const expectedRevision = stringArg(args?.expectedRevision);
+    if (!expectedRevision) {
+        throw new GroupMenuError('INVALID_ARGUMENT', 'args.expectedRevision is required for Group Menu updates', {
+            kind: 'revision_required',
+        });
+    }
+    const targetKind = target.scope === 'agent' ? ConfigTarget.Agent : ConfigTarget.Relation;
+    const mutation = mutateConfig(targetKind, target.selector, config => {
+        const override = configuredOverride(key, config);
+        const currentRevision = settingRevision(key, target, override);
+        if (currentRevision !== expectedRevision) {
+            throw new GroupMenuError('CONFLICT', 'The Group setting has changed', {
+                kind: 'revision_conflict',
+                expectedRevision,
+                currentRevision,
+            });
+        }
+        writeOverride(key, config, raw === 'clear' ? null : raw);
+    });
+    const state = readSettingState(key, target);
+    const compatibility = key === 'rulesPolicy'
+        ? groupRulesSessionCompatibility(context, target)
+        : undefined;
+    return {
+        ...settingResponse('resource', key, target, state),
+        changed: mutation.changed,
+        effectiveFrom: key === 'mentionMode'
+            ? 'next-message'
+            : compatibility?.sessionCompatibility.status === 'requires-new-session'
+                ? 'new-session'
+                : 'next-turn',
+        ...(compatibility ?? {}),
+    };
+}
+function settingResponse(selector, key, target, state) {
+    return {
+        [selector]: key,
+        scope: target.scope,
+        self: target.selector.self,
+        ...(target.selector.peerKey ? { peerKey: target.selector.peerKey } : {}),
+        ...(target.groupId ? { groupId: target.groupId } : {}),
+        override: state.override,
+        ...(state.mode ? { mode: state.mode, source: state.source } : {}),
+        ...(state.resolution ? { resolution: state.resolution } : {}),
+        revision: state.revision,
+    };
+}
+function readSettingState(key, target) {
+    const targetKind = target.scope === 'agent' ? ConfigTarget.Agent : ConfigTarget.Relation;
+    const local = readConfig(targetKind, target.selector, { cache: false });
+    const override = configuredOverride(key, local ?? {});
+    const revision = settingRevision(key, target, override);
+    const resolved = resolveEffectiveFieldWithSource(fieldPath(key), target.selector, { cache: false });
+    if (resolved.value !== undefined) {
+        const mode = validMode(key, resolved.value);
+        if (!mode) {
+            throw new GroupMenuError('INTERNAL_ERROR', `Configured ${key} value is invalid`);
+        }
+        return {
+            override,
+            mode,
+            source: sourceName(resolved.source) ?? 'builtin',
+            revision,
+        };
+    }
+    if (key === 'rulesPolicy') {
+        return { override, mode: 'load', source: 'builtin', revision };
+    }
+    if (target.scope === 'relation') {
+        return {
+            override,
+            mode: target.aunMentionMode ?? 'disabled',
+            source: target.aunMentionMode ? 'aun' : 'builtin',
+            revision,
+        };
+    }
+    return { override, resolution: 'per-group-aun', revision };
+}
+function configuredOverride(key, config) {
+    const value = key === 'mentionMode' ? config.mentionMode : config.groupRules?.mode;
+    if (value === undefined)
+        return null;
+    const mode = validMode(key, value);
+    if (!mode)
+        throw new GroupMenuError('INTERNAL_ERROR', `Stored ${key} override is invalid`);
+    return mode;
+}
+function validMode(key, value) {
+    if (key === 'mentionMode') {
+        return value === 'mention-only' || value === 'disabled' ? value : undefined;
+    }
+    return value === 'load' || value === 'ignore' ? value : undefined;
+}
+function writeOverride(key, config, value) {
+    if (key === 'mentionMode') {
+        if (value === null)
+            delete config.mentionMode;
+        else
+            config.mentionMode = value;
+        return;
+    }
+    const rules = config.groupRules && typeof config.groupRules === 'object' && !Array.isArray(config.groupRules)
+        ? { ...config.groupRules }
+        : {};
+    if (value === null)
+        delete rules.mode;
+    else
+        rules.mode = value;
+    if (Object.keys(rules).length === 0)
+        delete config.groupRules;
+    else
+        config.groupRules = rules;
+}
+function settingRevision(key, target, override) {
+    return `sha256:${crypto.createHash('sha256').update(JSON.stringify({
+        self: target.selector.self,
+        peerKey: target.selector.peerKey ?? null,
+        scope: target.scope,
+        resource: key,
+        override,
+    })).digest('hex')}`;
+}
+function documentRevision(value) {
+    return `sha256:${crypto.createHash('sha256').update(stableStringify(value)).digest('hex')}`;
+}
+function stableStringify(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(',')}]`;
+    if (!value || typeof value !== 'object')
+        return JSON.stringify(value);
+    return `{${Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, nested]) => `${JSON.stringify(key)}:${stableStringify(nested)}`)
+        .join(',')}}`;
+}
+function fieldPath(key) {
+    return key === 'mentionMode' ? 'mentionMode' : 'groupRules.mode';
+}
+function sourceName(source) {
+    if (source?.target === ConfigTarget.Relation)
+        return 'relation';
+    if (source?.target === ConfigTarget.Agent)
+        return 'agent';
+    if (source?.target === ConfigTarget.Defaults)
+        return 'defaults';
+    return null;
+}
+function groupRulesSessionCompatibility(context, target) {
+    const currentSessionAffected = !!context.currentGroupId
+        && (target.scope === 'agent' || target.groupId === context.currentGroupId);
+    if (!currentSessionAffected || !context.baseagent) {
+        return { sessionCompatibility: { status: 'not-evaluated' } };
+    }
+    const runner = context.baseagent.trim().toLowerCase();
+    const runnerKey = runner.replace(/[\s_-]+/g, '');
+    if (runnerKey === 'claude' || runnerKey === 'claudecode' || runnerKey === 'codex') {
+        return { sessionCompatibility: { status: 'supported', runner: context.baseagent } };
+    }
+    return {
+        sessionCompatibility: { status: 'requires-new-session', runner: context.baseagent },
+        note: `群规则加载策略已保存；当前会话使用的 ${context.baseagent} 不支持在恢复会话中更新群规则上下文。请新建或清空该群会话后生效。`,
+    };
+}
+function groupDirectory(context) {
+    return context.roleContext.directory ?? DEFAULT_DIRECTORY;
+}
+function assertAunAvailable(context) {
+    if (context.roleContext.aunAvailable === false) {
+        throw new GroupMenuError('NOT_SUPPORTED', 'Group Menu requires an enabled AUN channel');
+    }
+}
+function parseLimit(value) {
+    if (value === undefined)
+        return 50;
+    const limit = Number(value);
+    if (!Number.isInteger(limit) || limit < 1 || limit > 200) {
+        throw new GroupMenuError('INVALID_ARGUMENT', 'args.limit must be an integer between 1 and 200');
+    }
+    return limit;
+}
+function optionalString(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new GroupMenuError('INVALID_ARGUMENT', `${field} must be a non-empty string`);
+    }
+    return value.trim();
+}
+function stringArg(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}