ec-web 0.0.21 → 0.0.23

package/dist/sources/role-definitions.js

@@ -14,6 +14,7 @@
 import { getModelCatalogSnapshot } from './models.js';
 import { resolveParentDistModule, toFileUrl } from './parent-package.js';
 import { resolvePaths } from '../paths.js';
+import crypto from 'node:crypto';
 // 动态导入 evolcore 主项目的角色配置模块
 async function getRolesModule() {
     const rolesPath = resolveParentDistModule('config', 'roles.js');
@@ -82,6 +83,14 @@ async function getOperationRegistryModule() {
         listOperations: mod.listOperations,
     };
 }
+function ecwebAuditContext(auth, aid, operation) {
+    return {
+        ecwebRequestId: auth.ecwebRequestId ?? crypto.randomUUID(),
+        targetAgentAid: aid,
+        endpoint: auth.endpoint ?? 'ECWeb role policy',
+        logicalToolName: operation,
+    };
+}
 export function visibleRoleDefinitionOptions(roleOptions) {
     return roleOptions
         .filter(item => item?.kind === 'user' || item?.value === 'admin')
@@ -142,6 +151,7 @@ async function authorizeRolePolicyOperation(modules, processConfig, auth, aid, o
                 ...args,
             },
         },
+        auditMetadata: ecwebAuditContext(auth, aid, operation),
     });
 }
 function isDaemonOwnerAuth(processConfig, auth) {
@@ -268,7 +278,7 @@ function resolveRequestedAid(raw, agents) {
     return agents.find(agent => agent?.aid)?.aid || null;
 }
 function isReservedRoleName(roleName) {
-    return roleName === 'owner' || roleName === 'admin';
+    return roleName === 'owner' || roleName === 'admin' || roleName === 'daemon-owner';
 }
 function isValidUserRoleName(roleName) {
     return /^[a-z0-9_-]+$/.test(roleName) && !isReservedRoleName(roleName);
@@ -299,11 +309,12 @@ function normalizeDefaultRoleInput(value, current) {
         return value;
     return current ?? null;
 }
-function validateRoleDefinitionName(roleName) {
+function validateRoleDefinitionName(roleName, options = {}) {
     if (!roleName || !/^[a-z0-9_-]+$/.test(roleName))
         return 'Invalid role name';
-    if (isReservedRoleName(roleName))
-        return 'owner/admin are management identities and cannot be user role definitions';
+    if (isReservedRoleName(roleName) && (!options.allowManagement || roleName === 'daemon-owner')) {
+        return 'owner/admin/daemon-owner are management identities and cannot be user role definitions';
+    }
     return null;
 }
 function inferSelectionMode(allowedModels = []) {
@@ -547,12 +558,12 @@ async function filterAllowedCatalogModels(models, allowedModels) {
     const { isModelAllowedByPatterns } = await getRoleConstraintsModule();
     return models.filter(model => !model.isAlias && isModelAllowedByPatterns(model.id, allowedModels));
 }
-async function buildModelPermissionResponse(roleName, roleDef, override) {
+async function buildModelPermissionResponse(roleName, roleDef, override, aid) {
     const currentPerm = getModelPermission(roleDef);
     const defaultModel = override?.defaultModel ?? currentPerm.default ?? '';
     const allowOverride = override?.allowOverride ?? currentPerm.allowOverride ?? false;
     const allowedModels = override?.allowedModels ?? (Array.isArray(currentPerm.allowedModels) ? currentPerm.allowedModels : []);
-    const catalog = await getModelCatalogSnapshot('claude');
+    const catalog = await getModelCatalogSnapshot('claude', aid);
     const matchingModels = await filterAllowedCatalogModels(catalog.models, allowedModels);
     return {
         role: roleName,
@@ -574,6 +585,11 @@ async function buildModelPermissionResponse(roleName, roleDef, override) {
 }
 async function buildSnapshot(params = {}, auth = {}) {
     try {
+        auth = {
+            ...auth,
+            ecwebRequestId: params.__ecwebRequestId ?? auth.ecwebRequestId ?? crypto.randomUUID(),
+            endpoint: params.__ecwebEndpoint ?? auth.endpoint ?? 'WS snapshot:roleDefinitions',
+        };
         const agents = await getAgentsFromIpc();
         const aid = resolveRequestedAid(params.aid, agents);
         if (!aid)
@@ -614,7 +630,11 @@ async function buildSnapshot(params = {}, auth = {}) {
 export const roleDefinitionsSource = {
     kind: 'roleDefinitions',
     async snapshot(params = {}) {
-        return buildSnapshot(params, params.__menuAuth ?? {});
+        return buildSnapshot(params, {
+            ...(params.__menuAuth ?? {}),
+            ecwebRequestId: params.__ecwebRequestId,
+            endpoint: params.__ecwebEndpoint,
+        });
     },
     subscribe(_params, _push) {
         return () => { };
@@ -625,10 +645,16 @@ export async function handleRoleDefinitionsApi(req, res, auth = {}) {
     try {
         const parsedUrl = parseUrl(req.url || '');
         const urlPath = parsedUrl.path;
+        auth = {
+            ...auth,
+            ecwebRequestId: auth.ecwebRequestId ?? crypto.randomUUID(),
+            endpoint: auth.endpoint ?? `${req.method ?? 'UNKNOWN'} ${urlPath}`,
+        };
         const agents = await getAgentsFromIpc();
         const aid = resolveRequestedAid(parsedUrl.query.aid, agents);
         const modules = await getRolesModule();
         const { readRolesConfig, read, ConfigTarget } = modules;
+        let authorizationDecision = null;
         const roleRoute = urlPath.match(/^\/api\/role-definitions\/([^/]+)$/);
         const roleNestedRoute = urlPath.match(/^\/api\/role-definitions\/([^/]+)\/([^/]+)$/);
         const decodeRoleName = (raw) => {
@@ -655,6 +681,7 @@ export async function handleRoleDefinitionsApi(req, res, auth = {}) {
                 method: req.method,
                 path: urlPath,
             });
+            authorizationDecision = decision;
             if (!decision.allow) {
                 console.warn('[role-definitions] Role policy access forbidden:', {
                     method: req.method,
@@ -693,20 +720,40 @@ export async function handleRoleDefinitionsApi(req, res, auth = {}) {
             }
         }
         if (req.method === 'GET' && urlPath === '/api/role-definitions') {
-            sendJson(res, 200, await buildSnapshot({ aid }, auth));
+            sendJson(res, 200, await buildSnapshot({ aid, __ecwebRequestId: auth.ecwebRequestId, __ecwebEndpoint: auth.endpoint }, auth));
             return;
         }
         if (req.method === 'PUT' && urlPath === '/api/role-definitions') {
             try {
                 const incoming = await readJsonBody(req);
                 const currentConfig = readRolesConfig(aid || undefined);
+                // A complete snapshot may contain both management identities. Keep the
+                // same hierarchy guard used by the per-role endpoint for bulk updates.
+                if (!isDaemonOwnerAuth(read(ConfigTarget.Process) || {}, auth)
+                    && authorizationDecision?.subject?.role === 'admin'
+                    && incoming.roles && typeof incoming.roles === 'object'
+                    && Object.prototype.hasOwnProperty.call(incoming.roles, 'owner')) {
+                    sendJson(res, 403, {
+                        error: 'forbidden: agent admin cannot modify owner role policy',
+                        code: 'PERMISSION_DENIED',
+                        actorRole: 'admin',
+                    });
+                    return;
+                }
                 if (incoming.roles && typeof incoming.roles === 'object') {
                     for (const [roleName, roleDef] of Object.entries(incoming.roles)) {
-                        const nameError = validateRoleDefinitionName(roleName);
+                        // The collection endpoint receives the complete snapshot, including
+                        // management-role overrides. Creation of new management identities
+                        // remains forbidden; updates are narrowed by the runtime ceiling.
+                        const nameError = validateRoleDefinitionName(roleName, { allowManagement: true });
                         if (nameError) {
                             sendJson(res, 400, { error: `${nameError}: ${roleName}` });
                             return;
                         }
+                        if (isReservedRoleName(roleName) && !Object.prototype.hasOwnProperty.call(currentConfig.roles, roleName)) {
+                            sendJson(res, 404, { error: `Management role not found: ${roleName}` });
+                            return;
+                        }
                         const validation = await validateRoleModelPermission(roleDef);
                         if (!validation.ok) {
                             sendJson(res, 400, { error: `Invalid model permissions for role ${roleName}`, errors: validation.errors });
@@ -755,7 +802,7 @@ export async function handleRoleDefinitionsApi(req, res, auth = {}) {
                     }
                     writeRoleRegistry(modules, aid, nextDefaults);
                 }
-                sendJson(res, 200, { ok: true, data: await buildSnapshot({ aid }, auth) });
+                sendJson(res, 200, { ok: true, data: await buildSnapshot({ aid, __ecwebRequestId: auth.ecwebRequestId, __ecwebEndpoint: auth.endpoint }, auth) });
             }
             catch (err) {
                 console.error('[role-definitions] Failed to update agent role config:', err);
@@ -818,7 +865,7 @@ export async function handleRoleDefinitionsApi(req, res, auth = {}) {
                 sendJson(res, 404, { success: false, error: 'Role not found' });
                 return;
             }
-            const data = await buildModelPermissionResponse(roleName, roleDef);
+            const data = await buildModelPermissionResponse(roleName, roleDef, undefined, aid || undefined);
             sendJson(res, 200, { success: true, data });
             return;
         }
@@ -837,7 +884,7 @@ export async function handleRoleDefinitionsApi(req, res, auth = {}) {
                 sendJson(res, 400, { success: false, error: 'Invalid model permissions', errors: validation.errors });
                 return;
             }
-            const data = await buildModelPermissionResponse(roleName, roleDef, validation.value);
+            const data = await buildModelPermissionResponse(roleName, roleDef, validation.value, aid || undefined);
             sendJson(res, 200, { success: true, data });
             return;
         }
@@ -867,13 +914,13 @@ export async function handleRoleDefinitionsApi(req, res, auth = {}) {
                 allowedModels: validation.value.allowedModels,
             };
             modules.roleService.writeRoleDefinition(aid, roleName, roleDef);
-            const data = await buildModelPermissionResponse(roleName, roleDef, validation.value);
+            const data = await buildModelPermissionResponse(roleName, roleDef, validation.value, aid || undefined);
             sendJson(res, 200, { success: true, data });
             return;
         }
         if (req.method === 'POST' && roleNestedRoute?.[2] === 'reset') {
             const roleName = decodeRoleName(roleNestedRoute[1]);
-            if (!['admin', 'member', 'visitor'].includes(roleName)) {
+            if (!['owner', 'admin', 'member', 'visitor'].includes(roleName)) {
                 sendJson(res, 403, { error: 'Only builtin role overrides can be reset' });
                 return;
             }
@@ -916,7 +963,9 @@ export async function handleRoleDefinitionsApi(req, res, auth = {}) {
             try {
                 const roleName = decodeRoleName(roleRoute[1]);
                 const updates = await readJsonBody(req);
-                const nameError = validateRoleDefinitionName(roleName);
+                // owner/admin are reserved identities, but their policy definitions may
+                // be overridden (subject to the management-role ceiling).
+                const nameError = validateRoleDefinitionName(roleName, { allowManagement: true });
                 if (nameError) {
                     sendJson(res, 400, { error: nameError });
                     return;

package/dist/sources/session-codex.js

@@ -581,20 +581,32 @@ function approvalAuditFromPayload(payload) {
 }
 function classifyCodexToolRejection(text, payload) {
     const normalized = text.replace(/\\(["'])/g, '$1');
-    if (!/Rejected\(\s*["']rejected by user["']\s*\)/i.test(normalized))
+    const hookMatch = normalized.match(/(?:Command|Tool call) blocked by PreToolUse hook:\s*(.+?)(?:\.\s+(?:Command|Tool):|$)/is);
+    const genericRejected = /Rejected\(\s*["']rejected by user["']\s*\)/i.test(normalized);
+    if (!hookMatch && !genericRejected)
         return undefined;
     const audit = approvalAuditFromPayload(payload);
-    const source = audit.policyCode || audit.decisionSource?.toLowerCase().includes('policy')
+    const source = hookMatch || audit.policyCode || audit.decisionSource?.toLowerCase().includes('policy')
         ? 'evolcore-policy'
         : 'codex-approval';
+    const backendReason = hookMatch?.[1]?.trim()
+        || 'Rejected("rejected by user")';
+    const inferredPolicyCode = audit.policyCode
+        || (hookMatch && /工具调用已达到\s*\d+\s*次/.test(backendReason)
+            ? 'proactive_tool_report_required'
+            : hookMatch && /请先用\s+ec\s+(?:group\s+send|msg\s+send)/.test(backendReason)
+                ? 'proactive_first_send_required'
+                : undefined);
     return {
-        kind: 'approval_rejected',
+        kind: source === 'evolcore-policy' ? 'policy_blocked' : 'approval_rejected',
         source,
-        reason: 'rejected_by_user',
+        reason: source === 'evolcore-policy' ? 'policy_denied' : 'rejected_by_user',
         executed: false,
         evidence: audit.available ? 'structured_metadata' : 'backend_text',
-        backendReason: 'Rejected("rejected by user")',
-        audit,
+        backendReason,
+        audit: inferredPolicyCode && !audit.policyCode
+            ? { ...audit, policyCode: inferredPolicyCode }
+            : audit,
     };
 }
 export function parseCodexToolEvent(event) {

package/dist/sources/triggers.js

@@ -60,6 +60,63 @@ function normalizeAgent(item) {
         baseagent: typeof item?.baseagent === 'string' ? item.baseagent : undefined,
     };
 }
+function channelTypeFromKey(channelKey) {
+    const value = typeof channelKey === 'string' ? channelKey.trim() : '';
+    if (!value)
+        return '';
+    const separator = value.indexOf('#');
+    return separator > 0 ? value.slice(0, separator) : value;
+}
+function triggerScheduleView(definition, fallback) {
+    const source = definition?.source ?? fallback?.source;
+    if (source && typeof source === 'object') {
+        switch (source.type) {
+            case 'once': return { scheduleType: 'once', scheduleValue: '' };
+            case 'delay': return { scheduleType: 'delay', scheduleValue: String(source.afterMs ?? '') };
+            case 'at': return { scheduleType: 'at', scheduleValue: String(source.at ?? '') };
+            case 'cron': return { scheduleType: 'cron', scheduleValue: String(source.expression ?? '') };
+            case 'interval': return { scheduleType: 'interval', scheduleValue: String(source.everyMs ?? '') };
+            case 'event': return { scheduleType: 'event', scheduleValue: String(source.eventPattern ?? '') };
+            default: break;
+        }
+    }
+    return {
+        scheduleType: String(fallback?.scheduleType ?? ''),
+        scheduleValue: String(fallback?.scheduleValue ?? ''),
+    };
+}
+function triggerDisplayFields(definition, fallback) {
+    const feedback = definition?.feedback ?? fallback?.feedback;
+    const origin = definition?.origin;
+    const target = feedback?.strategy === 'target'
+        ? (feedback.target ?? fallback?.feedback?.target)
+        : feedback?.strategy === 'origin'
+            ? {
+                channelKey: origin?.channelKey,
+                channelId: origin?.channelId ?? origin?.peerId,
+                channelType: origin?.channelType,
+            }
+            : null;
+    const schedule = triggerScheduleView(definition, fallback);
+    const targetChannel = target?.channelKey ?? fallback?.targetChannel ?? '';
+    const targetChannelType = target?.channelType
+        ?? fallback?.targetChannelType
+        ?? (feedback?.strategy === 'target'
+            ? channelTypeFromKey(targetChannel)
+            : (origin?.channelType ?? channelTypeFromKey(targetChannel)));
+    return {
+        scheduleType: schedule.scheduleType,
+        scheduleValue: schedule.scheduleValue,
+        targetChannel,
+        targetChannelName: targetChannel || fallback?.targetChannelName || '',
+        targetChannelId: target?.channelId ?? fallback?.targetChannelId ?? '',
+        targetChannelType,
+        createdByPeerId: origin?.peerId ?? fallback?.createdByPeerId ?? '',
+        createdByChannel: origin?.channelKey ?? fallback?.createdByChannel ?? '',
+        createdAt: definition?.createdAt ?? fallback?.createdAt,
+        updatedAt: definition?.updatedAt ?? fallback?.updatedAt,
+    };
+}
 async function listTriggersForAgent(agentAid, agentLabel) {
     const p = resolvePaths();
     const controlToken = readTriggerControlToken(p.instanceDir);
@@ -106,6 +163,7 @@ async function listTriggersForAgent(agentAid, agentLabel) {
             revision,
             definitionError,
             subscription,
+            ...triggerDisplayFields(definition, trigger),
         };
     }));
 }