evolcore 0.0.2 → 0.0.3

package/dist/core/command/command-handler.js

@@ -18,6 +18,7 @@ import { buildSessionTurnList } from '../session/session-turns.js';
 import { resolveConfigCommand } from '../../config/resolved-config-op.js';
 import { AUTHENTICATED_CONFIG_ROLE_ENV, executeResolvedConfigCommand } from '../../config/config-operation-service.js';
 import { hashArgv } from '../auth/authorization-audit.js';
+import { executeResolvedContactCommand, resolveContactCommand } from '../../config/contact-operation-service.js';
 import { authorizeOperation, buildAuthSubject } from '../auth/auth-gateway.js';
 import { validateModelSelectionForRole } from '../model/model-permission.js';
 import { constrainRuntimePermissionMode, validateRuntimeStringFieldOverride } from '../role/runtime-policy.js';
@@ -353,10 +354,13 @@ export class CommandHandler {
     validateTriggerRuntimeFields(definition, role, baseagent) {
         if (!role)
             return undefined;
+        const executionBaseagent = definition.execution.type === 'trigger_session'
+            ? definition.execution.baseagent ?? baseagent
+            : baseagent;
         if (definition.execution.model) {
             const modelDecision = validateModelSelectionForRole({
                 role,
-                baseagent,
+                baseagent: executionBaseagent,
                 requestedModel: definition.execution.model,
                 selfAid: definition.agentAid,
             });
@@ -364,7 +368,7 @@ export class CommandHandler {
                 return modelDecision.message || '当前角色不允许使用该 Trigger 模型';
         }
         if (definition.execution.effort) {
-            const base = baseagent || 'claude';
+            const base = executionBaseagent || 'claude';
             const effortDecision = validateRuntimeStringFieldOverride({
                 selfAid: definition.agentAid,
                 role,
@@ -447,6 +451,29 @@ export class CommandHandler {
         const permissionError = this.validateTriggerPermissionModeForRole(permissionMode, isAdmin, triggerRole.role, schedulerAid);
         if (permissionError)
             return { error: permissionError };
+        if (parsed.baseagent !== undefined) {
+            if (typeof parsed.baseagent !== 'string' || !parsed.baseagent.trim()) {
+                return { error: 'Trigger baseagent 不能为空' };
+            }
+            if (parsed.executionType !== 'trigger_session') {
+                return { error: 'Trigger baseagent 仅适用于 trigger_session' };
+            }
+        }
+        const triggerOwner = this.agentRegistry?.get?.(schedulerAid) ?? this.getOwningAgent(channel);
+        const executionBaseagent = parsed.executionType === 'trigger_session'
+            ? parsed.baseagent?.trim() ?? triggerOwner?.baseagent ?? triggerRole.baseagent
+            : undefined;
+        if (parsed.executionType === 'trigger_session') {
+            if (!executionBaseagent)
+                return { error: '无法确定 Trigger 会话的 baseagent' };
+            const ownerName = triggerOwner?.name || '<unknown>';
+            const available = this.getAvailableBaseagentsForOwner(ownerName);
+            if (!available.includes(executionBaseagent)) {
+                return {
+                    error: `Trigger baseagent 不可用：${executionBaseagent}（可用：${available.join(' / ') || '无'}）`,
+                };
+            }
+        }
         const definition = {
             $schema_version: 3.1,
             id,
@@ -460,7 +487,10 @@ export class CommandHandler {
             execution: {
                 type: parsed.executionType,
                 ...(script ? { script } : { prompt: parsed.prompt || '' }),
-                ...(parsed.executionType === 'trigger_session' ? { thread: parsed.triggerThread ?? 'by_trigger' } : {}),
+                ...(parsed.executionType === 'trigger_session' ? {
+                    thread: parsed.triggerThread ?? 'by_trigger',
+                    baseagent: executionBaseagent,
+                } : {}),
                 model: parsed.model,
                 effort: parsed.effort,
                 ...(permissionMode !== undefined ? { permissionMode } : {}),
@@ -955,9 +985,9 @@ export class CommandHandler {
     /**
      * 主命令处理入口
      */
-    async handle(content, channel, channelId, sendMessage, userId, threadId, chatType, source, messageId, selfAID, overrideIdentity, authSubject) {
+    async handle(content, channel, channelId, sendMessage, userId, threadId, chatType, source, messageId, selfAID, overrideIdentity, authSubject, replyContext) {
         try {
-            const result = await this._handleInternal(content, channel, channelId, sendMessage, userId, threadId, chatType, source, messageId, selfAID, overrideIdentity, authSubject);
+            const result = await this._handleInternal(content, channel, channelId, sendMessage, userId, threadId, chatType, source, messageId, selfAID, overrideIdentity, authSubject, replyContext);
             return result;
         }
         catch (error) {
@@ -968,8 +998,8 @@ export class CommandHandler {
             throw error;
         }
     }
-    async _handleInternal(content, channel, channelId, sendMessage, userId, threadId, chatType, source, messageId, selfAID, overrideIdentity, authSubject) {
-        return await handleSlashCommand.call(this, content, channel, channelId, sendMessage, userId, threadId, chatType, source, messageId, selfAID, overrideIdentity, authSubject);
+    async _handleInternal(content, channel, channelId, sendMessage, userId, threadId, chatType, source, messageId, selfAID, overrideIdentity, authSubject, replyContext) {
+        return await handleSlashCommand.call(this, content, channel, channelId, sendMessage, userId, threadId, chatType, source, messageId, selfAID, overrideIdentity, authSubject, replyContext);
     }
     async handleTriggerCommand(scheduler, content, channel, channelId, peerId, isAdmin, messageId, chatType, threadId) {
         if (content === '/trigger') {
@@ -1117,8 +1147,13 @@ export class CommandHandler {
             const nextStr = updated.trigger.nextFireAt ? new Date(updated.trigger.nextFireAt).toLocaleString() : '未计算';
             return `✅ 触发器已更新：**${updated.trigger.name}**\n下次触发：${nextStr}`;
         }
-        if (sub.startsWith('set ')) {
-            const args = sub.slice('set '.length);
+        const createSubcommand = sub.startsWith('create ')
+            ? 'create'
+            : sub.startsWith('set ')
+                ? 'set'
+                : undefined;
+        if (createSubcommand) {
+            const args = sub.slice(`${createSubcommand} `.length);
             const result = parseTriggerSet(args);
             if (!result.ok)
                 return `❌ ${result.error}`;
@@ -1131,7 +1166,7 @@ export class CommandHandler {
         return `❌ 未知子命令。用法：
 /trigger — 查看活跃触发器
 /trigger list [--all] — 查看所有触发器
-/trigger set <参数> — 注册触发器
+/trigger create <参数> — 创建触发器（set 为兼容别名）
 /trigger update <名称|ID> <参数> — 修改触发器
 常用参数：--delay/--at/--cron/--every、--prompt、--model、--effort、--permission（省略则继承；update 可用 inherit 清除覆盖）
 /trigger enable <名称|ID> — 启用触发器
@@ -1477,6 +1512,66 @@ export class CommandHandler {
             ? { ok: true, result }
             : { ok: false, code: result.code, error: result.error, ...(result.data !== undefined ? { data: result.data } : {}) };
     }
+    /** Agent-managed contact CLI entrypoint. The daemon owns actor resolution and authorization. */
+    async handleContactOperation(argv, sessionId, delegationToken) {
+        if (!this.agentDelegationRegistry) {
+            return { ok: false, code: 'DELEGATION_REQUIRED', error: 'Task delegation is not configured' };
+        }
+        const delegation = this.agentDelegationRegistry.validate(delegationToken, sessionId);
+        if (!delegation.ok)
+            return { ok: false, code: delegation.code, error: delegation.reason };
+        const session = await this.sessionManager.getSessionById(sessionId);
+        if (!session)
+            return { ok: false, code: 'INVALID_SESSION', error: 'Invalid session' };
+        const grant = delegation.grant;
+        let conversationId;
+        try {
+            conversationId = parsePeerKey(grant.peerKey).channelId;
+        }
+        catch {
+            return { ok: false, code: 'INVALID_DELEGATION', error: 'Delegation contains an invalid relation key' };
+        }
+        const resolved = resolveContactCommand(argv);
+        if (!resolved.ok)
+            return { ok: false, code: resolved.code, error: resolved.reason };
+        if (resolved.command.selfAid !== grant.selfAid) {
+            return { ok: false, code: 'SCOPE_MISMATCH', error: 'Only the current Agent contact book can be targeted' };
+        }
+        const subject = buildAuthSubject({
+            selfAid: grant.selfAid,
+            actorId: grant.actorId,
+            channel: grant.channel,
+            channelType: grant.channelType,
+            channelId: conversationId,
+            chatType: grant.chatType,
+            conversationId,
+            processOwners: loadDaemonConfig().owners ?? [],
+        });
+        const decision = authorizeOperation({
+            source: 'agent-tool',
+            subject,
+            intent: {
+                operation: resolved.command.operationId,
+                scope: 'agent',
+                source: 'agent-tool',
+                args: {
+                    self: resolved.command.selfAid,
+                    ...('primaryId' in resolved.command ? { primaryId: resolved.command.primaryId } : {}),
+                },
+            },
+            auditMetadata: {
+                argvHash: hashArgv(resolved.command.canonicalArgv),
+                taskId: grant.taskId,
+                messageId: grant.messageId,
+            },
+        });
+        if (!decision.allow)
+            return { ok: false, code: decision.code, error: decision.reason };
+        const result = await executeResolvedContactCommand(resolved.command, grant.actorId);
+        return result.ok
+            ? { ok: true, result }
+            : { ok: false, code: result.code, error: result.error, ...(result.data ? { data: result.data } : {}) };
+    }
     setAgentDelegationRegistry(registry) {
         this.agentDelegationRegistry = registry;
     }

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

@@ -0,0 +1,374 @@
+import { roleMenuQuery, roleMenuUpdate, } from './role-menu.js';
+import { getContactSnapshot, resolveContactView } from '../../config/contact-book.js';
+import { mutateContactBook } from '../../config/contact-book-store.js';
+import { formatPeerKey, parsePeerKey } from '../relation/peer-identity.js';
+/**
+ * Connect Menu — 联系人与关系管理协议
+ *
+ * 定位：role menu 之上的**薄委派层**。
+ * - 角色分配 / admin（assignments、resource=assignment/admin）→ 委派给 role-menu，
+ *   复用其 agent 级互斥锁、CAS revision、owner/admin 安全护栏与审计链，绝不自行写 relation 文件。
+ * - 群组列表（view=groups）→ 委派给 role-menu 的 view=targets（数据源是 AUN live 目录），
+ *   群组不落 contact.json（contact book 只接受个人 AID，group 会被拒绝）。
+ * - 联系人（view=contacts / contact，add / block / unblock）→ 直接读写 Contact Book v2，
+ *   contact.json 是联系人列表的唯一事实来源。
+ */
+const MENU_NAME = 'connect';
+const DEFAULT_PAGE_SIZE = 50;
+const MAX_PAGE_SIZE = 200;
+/**
+ * Map a connect menu request to its authorization operation id.
+ * Read views/options → connect.read; contact writes → connect.write;
+ * role assignment/admin delegate to the role.* operations role-menu enforces.
+ */
+export function connectMenuOperation(kind, args, value) {
+    if (kind === 'options' || kind === 'query')
+        return 'connect.read';
+    if (kind === 'action')
+        return 'connect.write';
+    const resource = String(args?.resource ?? '');
+    if (resource === 'admin')
+        return 'connect.admin';
+    const decoded = decodeUpdateValue(value);
+    if (decoded === 'admin')
+        return 'connect.admin';
+    return decoded === null || decoded === false || decoded === 'revoke'
+        ? 'connect.revoke'
+        : 'connect.assign';
+}
+// ── Menu Entry ──
+export async function handleConnectMenu(req, context) {
+    const { self } = context;
+    if (!self)
+        return fail('INVALID_ARGUMENT', 'selfAid is required for connect menu');
+    if (req.args?.self !== self) {
+        return fail(req.args && Object.prototype.hasOwnProperty.call(req.args, 'self') ? 'PERMISSION_DENIED' : 'INVALID_ARGUMENT', req.args && Object.prototype.hasOwnProperty.call(req.args, 'self')
+            ? 'args.self does not match the receiving Agent'
+            : 'args.self is required for connect menu');
+    }
+    try {
+        if (req.subtype === 'options')
+            return await handleOptions(self);
+        if (req.subtype === 'query')
+            return await handleQuery(req, self, context);
+        if (req.subtype === 'update')
+            return await handleUpdate(req, context);
+        if (req.subtype === 'action')
+            return await handleAction(req, self, context);
+    }
+    catch (error) {
+        return fail(errorCode(error), errorMessage(error), errorData(error));
+    }
+    return fail('INVALID_ARGUMENT', `Unknown subtype: ${req.subtype}`);
+}
+// ── Options ──
+async function handleOptions(self) {
+    const snapshot = getContactSnapshot(self);
+    const contactCount = snapshot.contacts.size;
+    const blockedCount = snapshot.blockedIndex.size;
+    return ok({
+        options: [
+            {
+                option: 'contacts',
+                label: '联系人列表',
+                description: `查看所有联系人（${contactCount} 人，${blockedCount} 人已拉黑）`,
+            },
+            {
+                option: 'groups',
+                label: '群组列表',
+                description: '查看所在群组',
+            },
+        ],
+    });
+}
+// ── Query ──
+async function handleQuery(req, self, context) {
+    const args = req.args ?? {};
+    const view = String(args.view ?? '');
+    if (view === 'contacts')
+        return queryContacts(args, self);
+    if (view === 'contact')
+        return queryContact(req, self);
+    // Groups and role assignments are delegated to role-menu (authoritative source).
+    // Role *definitions* are out of scope here — use `menu name=role` for those.
+    if (view === 'groups') {
+        const data = await roleMenuQuery(context, { ...args, view: 'targets', targetType: 'group' });
+        return ok({
+            self,
+            view: 'groups',
+            items: (data.items ?? []).map((item) => ({
+                groupId: item.groupId,
+                peerKey: item.peerKey,
+                displayName: item.displayName,
+                status: item.status,
+                memberCount: item.memberCount,
+                roleId: item.explicitDefaultRole ?? null,
+                effectiveRoleId: item.baselineRole ?? null,
+                effectiveRoleSource: item.baselineRoleSource ?? null,
+                relationRevision: item.relationRevision,
+            })),
+            nextCursor: data.nextCursor ?? null,
+            total: data.total,
+            dataSource: data.dataSource,
+        });
+    }
+    if (view === 'assignments') {
+        const data = await roleMenuQuery(context, { ...args, view: 'assignments', includeDefaults: false });
+        return ok({
+            self,
+            view: 'assignments',
+            ...(args.roleId === undefined ? {} : { roleId: args.roleId }),
+            policyRevision: data.policyRevision,
+            items: (data.items ?? []).map(normalizeAssignmentItem),
+            nextCursor: data.nextCursor ?? null,
+            dataSource: { ...data.dataSource, kind: 'relation-config' },
+        });
+    }
+    return fail('INVALID_ARGUMENT', `Unknown view: ${String(view)}`);
+}
+function queryContacts(args, self) {
+    const snapshot = getContactSnapshot(self);
+    const page = paginate([...snapshot.contacts.keys()].sort(), args, self, primaryId => primaryId);
+    const items = page.items.map(primaryId => contactItem(self, primaryId));
+    return ok({
+        self,
+        view: 'contacts',
+        items,
+        contactRevision: snapshot.contactRevision,
+        nextCursor: page.nextCursor,
+        dataSource: { kind: 'contact-book', authoritative: true, complete: true },
+    });
+}
+function queryContact(req, self) {
+    const primaryId = String(req.args?.primaryId ?? '').trim();
+    if (!primaryId)
+        return fail('INVALID_ARGUMENT', 'primaryId is required');
+    const snapshot = getContactSnapshot(self);
+    if (!snapshot.contacts.has(primaryId))
+        return fail('NOT_FOUND', `Contact was not found: ${primaryId}`);
+    return ok({ self, view: 'contact', ...contactItem(self, primaryId), contactRevision: snapshot.contactRevision });
+}
+function contactItem(self, primaryId) {
+    const view = resolveContactView(self, primaryId);
+    return {
+        primaryId,
+        displayName: view.displayName ?? null,
+        status: view.status,
+        blocked: view.blocked,
+        isOwner: view.isOwner,
+        aliases: view.aliases,
+    };
+}
+function normalizeAssignmentItem(item) {
+    const peerKey = item?.target?.peerKey;
+    if (typeof peerKey !== 'string')
+        return item;
+    try {
+        const { channelType, channelId } = parsePeerKey(peerKey);
+        if (channelType === 'aun')
+            return item;
+        return {
+            ...item,
+            target: {
+                kind: item.target.kind,
+                channelType,
+                channelId,
+                peerKey,
+            },
+        };
+    }
+    catch {
+        return item;
+    }
+}
+// ── Update (delegated to role-menu) ──
+async function handleUpdate(req, context) {
+    const args = req.args ?? {};
+    const resource = args.resource;
+    if (resource !== 'assignment' && resource !== 'admin') {
+        return fail('INVALID_ARGUMENT', `Unknown resource: ${String(resource)}`);
+    }
+    if (req.value === undefined || !req.value.trim()) {
+        return fail('INVALID_ARGUMENT', 'value is required');
+    }
+    validateWritableTarget(args.target);
+    const value = roleMenuUpdateValue(resource, req.value);
+    const data = await roleMenuUpdate(context, args, value);
+    return ok(data);
+}
+// ── Action (Contact Book v2) ──
+async function handleAction(req, self, context) {
+    const action = req.action;
+    if (action === 'add')
+        return actionAdd(req, self, context);
+    if (action === 'block')
+        return actionSetStatus(req, self, context, true);
+    if (action === 'unblock')
+        return actionSetStatus(req, self, context, false);
+    return fail('INVALID_ARGUMENT', `Unknown action: ${String(action)}`);
+}
+async function actionAdd(req, self, context) {
+    const args = req.args ?? {};
+    const primaryId = String(args.primaryId ?? '').trim();
+    if (!primaryId)
+        return fail('INVALID_ARGUMENT', 'primaryId is required');
+    const expectedContactRevision = requireContactRevision(args);
+    const hasDisplayName = Object.prototype.hasOwnProperty.call(args, 'displayName');
+    if (hasDisplayName && args.displayName !== null && typeof args.displayName !== 'string') {
+        return fail('INVALID_ARGUMENT', 'displayName must be a string or null');
+    }
+    const current = getContactSnapshot(self).contacts.get(primaryId);
+    const displayName = hasDisplayName ? args.displayName : current?.displayName ?? null;
+    const result = await mutateContactBook({
+        selfAid: self,
+        actor: context.actorAid ?? 'connect-menu',
+        expectedContactRevision,
+        mutation: { type: 'set-display-name', primaryId, displayName },
+    });
+    const storedDisplayName = result.contact.contacts[primaryId]?.displayName ?? null;
+    return ok({
+        self,
+        action: 'add',
+        primaryId,
+        displayName: storedDisplayName,
+        changed: result.changed,
+        contactRevision: result.contactRevision,
+    });
+}
+async function actionSetStatus(req, self, context, blocked) {
+    const args = req.args ?? {};
+    const primaryId = String(args.primaryId ?? '').trim();
+    if (!primaryId)
+        return fail('INVALID_ARGUMENT', 'primaryId is required');
+    const expectedContactRevision = requireContactRevision(args);
+    const result = await mutateContactBook({
+        selfAid: self,
+        actor: context.actorAid ?? 'connect-menu',
+        expectedContactRevision,
+        mutation: { type: 'set-status', primaryId, status: blocked ? 'blocked' : 'active' },
+    });
+    return ok({
+        self,
+        action: blocked ? 'block' : 'unblock',
+        primaryId,
+        changed: result.changed,
+        contactRevision: result.contactRevision,
+    });
+}
+// ── Helpers ──
+function ok(data) {
+    return { type: 'menu.response', id: '', name: MENU_NAME, data };
+}
+function fail(code, message, data) {
+    return {
+        type: 'menu.response',
+        id: '',
+        name: MENU_NAME,
+        error: { code, message, ...(data === undefined ? {} : { data }) },
+    };
+}
+function errorCode(error) {
+    const code = error?.code;
+    if (code === 'INVALID_AID')
+        return 'INVALID_ARGUMENT';
+    if (code === 'OWNER_PROTECTED')
+        return 'NOT_ALLOWED';
+    if (code === 'ALIAS_CONFLICT')
+        return 'CONFLICT';
+    if (code === 'INVALID_CONTACT_BOOK')
+        return 'INTERNAL_ERROR';
+    return typeof code === 'string' ? code : 'INTERNAL_ERROR';
+}
+function errorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    const message = error?.message;
+    return typeof message === 'string' ? message : String(error);
+}
+function errorData(error) {
+    return error && typeof error === 'object' ? error.data : undefined;
+}
+function requireContactRevision(args) {
+    if (!Object.prototype.hasOwnProperty.call(args, 'expectedContactRevision')) {
+        throw connectError('INVALID_ARGUMENT', 'expectedContactRevision is required');
+    }
+    if (typeof args.expectedContactRevision !== 'string' || !args.expectedContactRevision) {
+        throw connectError('INVALID_ARGUMENT', 'expectedContactRevision must be a non-empty string');
+    }
+    return args.expectedContactRevision;
+}
+function decodeUpdateValue(value) {
+    const text = String(value ?? '').trim();
+    if (!text)
+        return undefined;
+    try {
+        const decoded = JSON.parse(text);
+        if (decoded === null || typeof decoded === 'string' || typeof decoded === 'boolean')
+            return decoded;
+    }
+    catch { }
+    return text;
+}
+function roleMenuUpdateValue(resource, value) {
+    const decoded = decodeUpdateValue(value);
+    if (resource === 'assignment') {
+        if (decoded !== null && typeof decoded !== 'string') {
+            throw connectError('INVALID_ARGUMENT', 'assignment value must be a role ID or null');
+        }
+        return JSON.stringify(decoded);
+    }
+    if (![true, false, null, 'grant', 'revoke'].includes(decoded)) {
+        throw connectError('INVALID_ARGUMENT', 'admin value must be grant or revoke');
+    }
+    return JSON.stringify(decoded);
+}
+function validateWritableTarget(target) {
+    if (!target || typeof target !== 'object' || Array.isArray(target))
+        return;
+    const value = target;
+    if (typeof value.channelType === 'string' && value.channelType !== 'aun') {
+        throw connectError('NOT_SUPPORTED', 'Native non-AUN assignment writes are not supported in Phase 1');
+    }
+    const kind = value.kind;
+    const logicalId = kind === 'private' ? value.peerAid : kind === 'group' ? value.groupId : undefined;
+    if (value.peerKey === undefined || typeof logicalId !== 'string')
+        return;
+    const expected = formatPeerKey('aun', logicalId);
+    if (value.peerKey !== expected) {
+        throw connectError('INVALID_ARGUMENT', 'target.peerKey does not match the logical target', {
+            expectedPeerKey: expected,
+            peerKey: value.peerKey,
+        });
+    }
+}
+function paginate(items, args, self, key) {
+    const requestedLimit = Number(args.limit ?? DEFAULT_PAGE_SIZE);
+    const limit = Number.isInteger(requestedLimit) && requestedLimit > 0
+        ? Math.min(requestedLimit, MAX_PAGE_SIZE)
+        : DEFAULT_PAGE_SIZE;
+    let start = 0;
+    if (args.cursor !== undefined && args.cursor !== null) {
+        try {
+            const decoded = JSON.parse(Buffer.from(String(args.cursor), 'base64url').toString('utf8'));
+            if (!decoded || typeof decoded.after !== 'string')
+                throw new Error();
+            start = items.findIndex(item => key(item) > decoded.after);
+            if (start < 0)
+                start = items.length;
+        }
+        catch {
+            throw connectError('INVALID_ARGUMENT', 'cursor is invalid', { self, field: 'cursor' });
+        }
+    }
+    const page = items.slice(start, start + limit);
+    const hasMore = start + page.length < items.length;
+    return {
+        items: page,
+        nextCursor: hasMore && page.length
+            ? Buffer.from(JSON.stringify({ after: key(page[page.length - 1]) }), 'utf8').toString('base64url')
+            : null,
+    };
+}
+function connectError(code, message, data) {
+    return Object.assign(new Error(message), { code, ...(data === undefined ? {} : { data }) });
+}