evolcore 0.0.3 → 0.0.4

package/dist/config/access-policy-domain.js

@@ -0,0 +1,38 @@
+import { isValidAid } from '../aun/aid/validation.js';
+export function validAgentOwnerIds(agent) {
+    return [...new Set((agent?.owners ?? [])
+            .map(value => String(value || '').trim())
+            .filter(isValidAid))];
+}
+export function configuredChannelKeys(selfAid, agent) {
+    const keys = (agent?.channels ?? [])
+        .filter(channel => channel && channel.enabled !== false)
+        .map(channel => {
+        const type = String(channel.type || '').trim().toLowerCase();
+        const name = String(channel.name || '').trim();
+        return type && name ? `${type}#${selfAid}#${name}` : '';
+    })
+        .filter(Boolean);
+    keys.push(`aun#${selfAid}#main`);
+    return [...new Set(keys)];
+}
+export function validateAccessPolicyDomain(selfAid, agent) {
+    const access = agent.access;
+    if (!access)
+        return undefined;
+    if (access.policyMode !== 'open' && validAgentOwnerIds(agent).length === 0) {
+        return {
+            code: 'restricted_mode_without_owner',
+            message: `Agent ${selfAid} cannot use ${access.policyMode} without an Owner`,
+        };
+    }
+    const configured = new Set(configuredChannelKeys(selfAid, agent));
+    const unknown = access.allowedGroupChannels.find(channelKey => !configured.has(channelKey));
+    if (unknown) {
+        return {
+            code: 'unknown_group_access_channel',
+            message: `Group access channel is not configured or enabled for ${selfAid}: ${unknown}`,
+        };
+    }
+    return undefined;
+}

package/dist/config/access-policy.js

@@ -0,0 +1,134 @@
+import crypto from 'crypto';
+import { ConfigError, ConfigTarget, mutateConfig, read, validateConfig, } from './config-manager.js';
+import { configuredChannelKeys, validAgentOwnerIds, validateAccessPolicyDomain, } from './access-policy-domain.js';
+export class AccessPolicyError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = 'AccessPolicyError';
+    }
+}
+export const DEFAULT_ACCESS_POLICY = Object.freeze({
+    policyMode: 'open',
+    allowedGroupChannels: Object.freeze([]),
+    requestLimit: Object.freeze({ maxTimes: 600, coolDown: 60 * 60 }),
+});
+export function listAgentOwners(selfAid) {
+    const agent = read(ConfigTarget.Agent, { self: selfAid }, { cache: true });
+    return validAgentOwnerIds(agent);
+}
+export function listConfiguredChannelKeys(selfAid) {
+    const agent = read(ConfigTarget.Agent, { self: selfAid }, { cache: true });
+    if (!agent)
+        return [];
+    return configuredChannelKeys(selfAid, agent);
+}
+/** Missing AgentConfig.access uses the compatibility view; malformed Agent config never does. */
+export function readAccessPolicy(selfAid) {
+    return readAccessPolicySnapshot(selfAid).policy;
+}
+export function readAccessPolicySnapshot(selfAid) {
+    const agent = read(ConfigTarget.Agent, { self: selfAid }, { cache: true });
+    return accessPolicySnapshotFromAgent(selfAid, agent);
+}
+/**
+ * Atomically updates AgentConfig.access through Config Manager's file-scoped
+ * mutation path. The callback always receives the newest persisted policy.
+ */
+export function mutateAccessPolicy(input) {
+    try {
+        const result = mutateConfig(ConfigTarget.Agent, { self: input.selfAid }, agent => {
+            const current = accessPolicySnapshotFromAgent(input.selfAid, agent);
+            if (input.expectedAccessRevision !== current.accessRevision) {
+                throw new AccessPolicyError('access_policy_revision_conflict', 'Access policy changed since it was read', {
+                    expectedAccessRevision: input.expectedAccessRevision,
+                    accessRevision: current.accessRevision,
+                });
+            }
+            const next = input.update(clonePolicy(current.policy));
+            assertAccessPolicyWrite(input, agent, current.policy, next);
+            agent.access = clonePolicy(next);
+            return {
+                policy: clonePolicy(next),
+                accessRevision: accessPolicyRevision(next),
+            };
+        });
+        return { ...result.value, changed: result.changed };
+    }
+    catch (error) {
+        if (error instanceof AccessPolicyError)
+            throw error;
+        if (error instanceof ConfigError && error.code === 'LOCK_TIMEOUT') {
+            throw new AccessPolicyError('access_policy_temporarily_unavailable', 'Access policy is temporarily unavailable');
+        }
+        if (error instanceof ConfigError) {
+            throw new AccessPolicyError('invalid_access_policy', error.message);
+        }
+        throw error;
+    }
+}
+function accessPolicySnapshotFromAgent(selfAid, agent) {
+    if (!agent) {
+        throw new AccessPolicyError('invalid_access_policy', `Agent config does not exist: ${selfAid}`);
+    }
+    const errors = validateConfig(ConfigTarget.Agent, agent);
+    if (errors.length > 0) {
+        throw new AccessPolicyError('invalid_access_policy', `Invalid access policy for ${selfAid}: ${errors.join('; ')}`);
+    }
+    const issue = validateAccessPolicyDomain(selfAid, agent);
+    if (issue)
+        throw new AccessPolicyError(issue.code, issue.message);
+    const access = agent.access ?? DEFAULT_ACCESS_POLICY;
+    const policy = clonePolicy(access);
+    return { policy, accessRevision: accessPolicyRevision(policy) };
+}
+function assertAccessPolicyWrite(input, agent, current, policy) {
+    const owners = validAgentOwnerIds(agent);
+    const normalizedActorAid = String(input.actorAid || '').trim();
+    const isOwner = input.actorRole === 'owner' || owners.includes(normalizedActorAid);
+    const isGroupChannelAdmin = input.actorRole === 'admin' && input.resource === 'access.allowedGroupChannels';
+    if (!isOwner && !isGroupChannelAdmin) {
+        if (input.resource === 'access.allowedGroupChannels') {
+            throw new AccessPolicyError('access_policy_manager_required', 'Only an Agent Owner or Admin can change allowed group channels');
+        }
+        throw new AccessPolicyError('access_policy_owner_required', 'Only an Agent Owner can change access policy');
+    }
+    if (isGroupChannelAdmin) {
+        if (current.policyMode !== policy.policyMode
+            || current.requestLimit.maxTimes !== policy.requestLimit.maxTimes
+            || current.requestLimit.coolDown !== policy.requestLimit.coolDown) {
+            throw new AccessPolicyError('access_policy_owner_required', 'An Agent Admin may only change allowed group channels');
+        }
+    }
+    if (policy.policyMode !== 'open' && owners.length === 0) {
+        throw new AccessPolicyError('restricted_mode_without_owner', `Agent ${input.selfAid} cannot use ${policy.policyMode} without an Owner`);
+    }
+    const configured = new Set(configuredChannelKeys(input.selfAid, agent));
+    const unknown = policy.allowedGroupChannels.find(channelKey => !configured.has(channelKey));
+    if (unknown) {
+        throw new AccessPolicyError('unknown_group_access_channel', `Group access channel is not configured or enabled for ${input.selfAid}: ${unknown}`);
+    }
+}
+function clonePolicy(policy) {
+    return {
+        policyMode: policy.policyMode,
+        allowedGroupChannels: [...policy.allowedGroupChannels],
+        requestLimit: { ...policy.requestLimit },
+    };
+}
+function accessPolicyRevision(policy) {
+    return `sha256:${crypto.createHash('sha256').update(stableStringify(policy)).digest('hex')}`;
+}
+function stableStringify(value) {
+    return JSON.stringify(sortValue(value));
+}
+function sortValue(value) {
+    if (Array.isArray(value))
+        return value.map(sortValue);
+    if (!value || typeof value !== 'object')
+        return value;
+    return Object.fromEntries(Object.keys(value).sort().map(key => [key, sortValue(value[key])]));
+}

package/dist/config/builtin-role-templates.js

@@ -1,6 +1,6 @@
-import fs from 'fs';
 import path from 'path';
 import { kitsRoleTemplatesDir } from '../paths.js';
+import { createErrorCapturingReader, fileCache } from '../core/daemon-file-cache.js';
 import { validateRoleConfig } from './role-schema.js';
 import { expectedRoleRank } from './role-ranks.js';
 export const BUILTIN_ROLE_IDS = ['owner', 'admin', 'member', 'visitor'];
@@ -24,19 +24,32 @@ export function validateBuiltinRoleTemplateDefinition(roleId, raw) {
     }
     return { definition: definition };
 }
-/** Load the versioned package template that defines a built-in role policy. */
+/**
+ * Load the versioned package template that defines a built-in role policy.
+ *
+ * 模板随包发布、只靠进程重启或 kit 缓存失效刷新 → fileCache 的 on-reload 策略，
+ * 归入 'kits' 组。缓存的是"读盘 + JSON.parse"结果；校验（validateRoleConfig）仍每次现做。
+ */
 export function readBuiltinRoleTemplate(roleId) {
     const file = path.join(kitsRoleTemplatesDir(), `${roleId}.json`);
-    let raw;
-    try {
-        raw = JSON.parse(fs.readFileSync(file, 'utf8'));
-    }
-    catch (error) {
-        return {
-            definition: null,
-            file,
-            error: `cannot read built-in role template: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-    return { ...validateBuiltinRoleTemplateDefinition(roleId, raw), file };
+    // 默认 reader 会把所有读盘异常吞成 null（分不清 ENOENT 与 EACCES），
+    // 这里注入带错误捕获的 reader 把真实错误原文带出来，保持与直读时一致的报错。
+    const reader = createErrorCapturingReader();
+    const parsed = fileCache.get(file, (text) => {
+        if (text === null) {
+            return { error: `cannot read built-in role template: ${reader.lastError()}` };
+        }
+        try {
+            return { raw: JSON.parse(text) };
+        }
+        catch (error) {
+            return { error: `cannot read built-in role template: ${error instanceof Error ? error.message : String(error)}` };
+        }
+    }, { policy: 'on-reload', group: 'kits', read: reader.read });
+    if ('error' in parsed)
+        return { definition: null, file, error: parsed.error };
+    // 缓存返回的是同一个对象引用，而 validateBuiltinRoleTemplateDefinition 里的解构
+    // 只隔离顶层——permissions / commandPermissions / usageLimits 等嵌套对象仍会被
+    // 所有调用方共享，任何一处改写都会污染后续读者拿到的授权策略。整份深拷贝后再校验。
+    return { ...validateBuiltinRoleTemplateDefinition(roleId, structuredClone(parsed.raw)), file };
 }

package/dist/config/builtin-roles.js

@@ -21,17 +21,23 @@ export function getBuiltinRolesConfig() {
     };
 }
 /**
- * Management grants are a code-level ceiling, not configurable role policy.
- * A role file may narrow these rules but can never add a management grant.
+ * Management grants are a code-level ceiling. The built-in admin template
+ * declares the default grants; local role files may narrow them but can never
+ * add a grant outside this ceiling.
  */
 export function getManagementCommandPermissions(role) {
     return {
         'contact.read': { allow: true, scopes: ['agent'] },
-        'contact.block': { allow: true, scopes: ['agent'] },
+        'contact.block': { allow: true, scopes: ['agent'], constraints: { requireAgentAdmin: true } },
+        'connect.write': { allow: true, scopes: ['agent'], constraints: { requireAgentAdmin: true } },
+        'connect.access.write': { allow: true, scopes: ['agent'], constraints: { requireAgentOwner: true } },
         'role.assign': { allow: true, scopes: ['agent'] },
         'role.revoke': { allow: true, scopes: ['agent'] },
         'role.policy.read': { allow: true, scopes: ['agent'] },
         'role.relation.read': { allow: true, scopes: ['agent'] },
+        'config.get': { allow: true, scopes: ['agent', 'relation'] },
+        'config.set': { allow: true, scopes: ['agent', 'relation'] },
+        'config.unset': { allow: true, scopes: ['agent', 'relation'] },
         'role.policy.write': { allow: true, dangerous: true, scopes: ['agent'], constraints: { requireAgentAdmin: true } },
         '*': { allow: true },
         'agent.reload': { allow: true, dangerous: true, scopes: ['agent'], constraints: { targetCurrentAgentOnly: true, requireAgentAdmin: true } },
@@ -39,6 +45,7 @@ export function getManagementCommandPermissions(role) {
     };
 }
 export function applyManagementRoleCeiling(role, configured) {
+    const builtin = readBuiltinRoleTemplate(role).definition;
     const fallback = {
         description: role === 'owner' ? 'Agent owner' : 'Agent administrator',
         rank: expectedRoleRank(role),
@@ -48,12 +55,16 @@ export function applyManagementRoleCeiling(role, configured) {
         },
         commandPermissions: getManagementCommandPermissions(role),
     };
-    const policy = configured ?? readBuiltinRoleTemplate(role).definition ?? fallback;
+    const policy = configured ?? builtin ?? fallback;
+    const configuredCommandPermissions = policy.commandPermissions;
+    const defaultCommandPermissions = configuredCommandPermissions
+        ?? (role === 'admin' && builtin ? builtin.commandPermissions : undefined)
+        ?? getManagementCommandPermissions(role);
     return {
         ...policy,
         rank: expectedRoleRank(role),
-        allowAccess: true,
-        commandPermissions: narrowManagementCommandPermissions(getManagementCommandPermissions(role), policy.commandPermissions || {}),
+        allowAccess: role === 'owner' ? true : policy.allowAccess !== false,
+        commandPermissions: narrowManagementCommandPermissions(getManagementCommandPermissions(role), defaultCommandPermissions),
     };
 }
 export function getManagementRoleDefinition(role) {
@@ -78,6 +89,14 @@ function narrowManagementCommandPermissions(ceiling, configured) {
         else if (!Array.isArray(permission.scopes) && Array.isArray(override.scopes)) {
             next.scopes = [...override.scopes];
         }
+        if (permission.constraints || override.constraints) {
+            // Configured constraints may add restrictions, but a role file cannot
+            // weaken a code-level constraint (the ceiling wins on collisions).
+            next.constraints = {
+                ...(override.constraints ?? {}),
+                ...(permission.constraints ?? {}),
+            };
+        }
         merged[operation] = next;
     }
     // Exact or namespace denies may narrow grants inherited through the ceiling's

package/dist/config/config-field-policy.js

@@ -8,6 +8,7 @@ const BEHAVIOR_TOP_FIELDS = new Set([
     'debounce',
     'show_activities',
     'session_renew',
+    'groupRules',
     'group_venue_sync',
     'render',
     'sessionManifests',
@@ -32,6 +33,7 @@ const SENSITIVE_TOP_FIELDS = new Set([
     'lifecycle',
     'initialized',
     'owners',
+    'access',
     'admins',
     'channels',
     'aun',
@@ -44,10 +46,10 @@ const SENSITIVE_TOP_FIELDS = new Set([
     'role',
     'extra_backup',
 ]);
-const CRITICAL_AGENT_FIELDS = new Set(['owners', 'admins', 'roles']);
+const CRITICAL_AGENT_FIELDS = new Set(['owners', 'admins', 'roles', 'access']);
 const EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
-function scalar(rolePermissionKey, valueKind) {
-    return { class: 'safe-scalar', rolePermissionKey, valueKind };
+function scalar(rolePermissionKey, valueKind, access = 'role-overridable') {
+    return { class: 'safe-scalar', access, rolePermissionKey, valueKind };
 }
 function readonlyObject(rolePermissionKey) {
     return { class: 'safe-readonly-object', rolePermissionKey };
@@ -133,8 +135,6 @@ export function resolveConfigFieldRule(fieldPath) {
             return scalar('session_renew', 'boolean');
         if (parts[1] === 'after_hours')
             return scalar('session_renew', 'positive-number');
-        if (parts[1] === 'effort')
-            return scalar('session_renew', 'effort');
         if (parts[1] === 'fallback_action')
             return scalar('session_renew', 'session-renew-action');
         return { class: 'unknown' };
@@ -153,6 +153,14 @@ export function resolveConfigFieldRule(fieldPath) {
             return scalar('sessionManifests', 'manifest-file');
         return { class: 'unknown' };
     }
+    if (top === 'groupRules') {
+        if (parts.length === 1)
+            return readonlyObject('groupRules');
+        if (field === 'groupRules.mode') {
+            return scalar(field, 'group-rules-mode', 'owner-only');
+        }
+        return { class: 'unknown' };
+    }
     if (top === 'group_venue_sync')
         return parts.length === 1
             ? readonlyObject('group_venue_sync')
@@ -257,5 +265,9 @@ export function parseConfigFieldValue(fieldPath, rawValue) {
             return raw === 'continue' || raw === 'new'
                 ? { ok: true, value: raw }
                 : { ok: false, reason: `Config field ${fieldPath} must be continue or new` };
+        case 'group-rules-mode':
+            return raw === 'load' || raw === 'ignore'
+                ? { ok: true, value: raw }
+                : { ok: false, reason: `Config field ${fieldPath} must be load or ignore` };
     }
 }