evolcore 0.0.2 → 0.0.4

package/dist/config/config-operation-service.js

@@ -1,4 +1,4 @@
-import { ConfigError, ConfigTarget, ensureFile, listFields, read, resolveEffectiveFieldWithSource, resolveEffectiveWithSources, validateConfigFile, write, } from './config-manager.js';
+import { ConfigError, ConfigTarget, ensureFile, listFields, mutateConfig, read, resolveEffectiveFieldWithSource, resolveEffectiveWithSources, validateConfigFile, } from './config-manager.js';
 import { collectConfigFiles, diffVersions, listAllVersions, prune, readCurrent, restore, snapshot, isConfigSnapshotsEnabled, } from './snapshot.js';
 import { readBootLog } from './boot-log.js';
 import { currentVersion, fieldSchemaDefault, isSchemaName, listSchemaNames, listSchemaVersions, readRawSchema, schemaHistoryEntry, } from './schema-registry.js';
@@ -302,27 +302,26 @@ function executeSet(op, options) {
     if (!op.route)
         return { ok: false, code: 'UNKNOWN_FIELD', error: `Unknown config field: ${op.field}` };
     const selector = selectorFor(op, options);
-    const existing = read(op.route.target, selector) || {};
-    if (op.route.merge === 'list') {
-        const previous = getNested(existing, op.field);
-        const previousItems = Array.isArray(previous) ? previous : [];
-        const nextItems = Array.isArray(op.value) ? op.value : [op.value];
-        const merged = [...new Set([...previousItems, ...nextItems].map(value => typeof value === 'object' ? JSON.stringify(value) : value))]
-            .map(value => {
-            try {
-                return typeof value === 'string' && value.startsWith('{') ? JSON.parse(value) : value;
-            }
-            catch {
-                return value;
-            }
-        });
-        setNested(existing, op.field, merged);
-    }
-    else {
-        setNested(existing, op.field, op.value);
-    }
-    ensureFile(op.route.target, selector);
-    write(op.route.target, existing, selector);
+    mutateConfig(op.route.target, selector, existing => {
+        if (op.route.merge === 'list') {
+            const previous = getNested(existing, op.field);
+            const previousItems = Array.isArray(previous) ? previous : [];
+            const nextItems = Array.isArray(op.value) ? op.value : [op.value];
+            const merged = [...new Set([...previousItems, ...nextItems].map(value => typeof value === 'object' ? JSON.stringify(value) : value))]
+                .map(value => {
+                try {
+                    return typeof value === 'string' && value.startsWith('{') ? JSON.parse(value) : value;
+                }
+                catch {
+                    return value;
+                }
+            });
+            setNested(existing, op.field, merged);
+        }
+        else {
+            setNested(existing, op.field, op.value);
+        }
+    });
     return {
         ok: true,
         subcommand: 'set',
@@ -336,22 +335,20 @@ function executeUnset(op, options) {
     if (!op.route)
         return { ok: false, code: 'UNKNOWN_FIELD', error: `Unknown config field: ${op.field}` };
     const selector = selectorFor(op, options);
-    const existing = read(op.route.target, selector);
-    if (!existing) {
-        return { ok: true, subcommand: 'unset', field: op.field, removed: false, scope: op.configScope };
-    }
-    const parts = op.field.split('.');
-    let current = existing;
-    for (let i = 0; i < parts.length - 1; i++) {
-        if (current == null)
-            break;
-        current = current[parts[i]];
-    }
-    const leaf = parts[parts.length - 1];
-    const removed = !!current && typeof current === 'object' && Object.prototype.hasOwnProperty.call(current, leaf);
-    if (removed)
-        delete current[leaf];
-    write(op.route.target, existing, selector);
+    const { value: removed } = mutateConfig(op.route.target, selector, existing => {
+        const parts = op.field.split('.');
+        let current = existing;
+        for (let i = 0; i < parts.length - 1; i++) {
+            if (current == null)
+                break;
+            current = current[parts[i]];
+        }
+        const leaf = parts[parts.length - 1];
+        const exists = !!current && typeof current === 'object' && Object.prototype.hasOwnProperty.call(current, leaf);
+        if (exists)
+            delete current[leaf];
+        return exists;
+    });
     return { ok: true, subcommand: 'unset', field: op.field, removed, scope: op.configScope };
 }
 function selectorFor(command, options = {}) {

package/dist/config/contact-alias.js

@@ -0,0 +1,68 @@
+import { isValidAid } from '../aun/aid/validation.js';
+const CHANNEL_SEGMENT = /^[A-Za-z0-9_-]+$/;
+/** Parse the canonical channel instance key used by Contact aliases. */
+export function parseContactChannelKey(value) {
+    if (typeof value !== 'string')
+        return null;
+    const text = value.trim();
+    const parts = text.split('#');
+    if (parts.length !== 3)
+        return null;
+    const [rawType, selfAid, channelName] = parts;
+    const channelType = rawType.toLowerCase();
+    if (!CHANNEL_SEGMENT.test(channelType)
+        || rawType !== channelType
+        || !isValidAid(selfAid)
+        || !CHANNEL_SEGMENT.test(channelName))
+        return null;
+    return {
+        channelType,
+        selfAid,
+        channelName,
+        channelKey: `${channelType}#${selfAid}#${channelName}`,
+    };
+}
+/** Validate that a runtime channelKey belongs to the expected Agent and channel type. */
+export function normalizeContactChannelKey(selfAid, channelType, channelKey) {
+    const parsed = parseContactChannelKey(channelKey);
+    const expectedType = String(channelType || '').trim().toLowerCase();
+    const expectedSelf = String(selfAid || '').trim();
+    if (!parsed || parsed.channelType !== expectedType || parsed.selfAid !== expectedSelf)
+        return null;
+    return parsed.channelKey;
+}
+/** Format `<channelKey>:<urlEncode(peerId)>`. */
+export function formatContactAlias(channelKey, peerId) {
+    const parsed = parseContactChannelKey(channelKey);
+    const peer = String(peerId || '').trim();
+    if (!parsed || parsed.channelType === 'aun' || !peer) {
+        throw new Error(`Invalid Contact alias input: ${String(channelKey)}:${String(peerId)}`);
+    }
+    return `${parsed.channelKey}:${encodeURIComponent(peer)}`;
+}
+/** Parse and canonicalize a stored Contact alias. Non-canonical URL encoding is rejected. */
+export function parseContactAlias(value, expectedSelfAid) {
+    if (typeof value !== 'string')
+        return null;
+    const text = value.trim();
+    const separator = text.indexOf(':');
+    if (separator <= 0 || separator === text.length - 1)
+        return null;
+    const parsedChannel = parseContactChannelKey(text.slice(0, separator));
+    if (!parsedChannel || parsedChannel.channelType === 'aun')
+        return null;
+    if (expectedSelfAid !== undefined && parsedChannel.selfAid !== String(expectedSelfAid || '').trim())
+        return null;
+    const encodedPeerId = text.slice(separator + 1);
+    let peerId;
+    try {
+        peerId = decodeURIComponent(encodedPeerId);
+    }
+    catch {
+        return null;
+    }
+    if (!peerId || encodeURIComponent(peerId) !== encodedPeerId)
+        return null;
+    const alias = `${parsedChannel.channelKey}:${encodedPeerId}`;
+    return { ...parsedChannel, peerId, alias };
+}

package/dist/config/contact-bind-code.js

@@ -0,0 +1,274 @@
+import { randomInt } from 'crypto';
+import { isValidAid } from '../aun/aid/validation.js';
+import { isAcceptedContact, resolveContactView } from './contact-book.js';
+import { formatContactAlias, normalizeContactChannelKey } from './contact-alias.js';
+import { mutateContactBookSync } from './contact-book-store.js';
+export const CONTACT_BIND_CODE_TTL_MS = 10 * 60 * 1000;
+export const CONTACT_BIND_MAX_FAILED_ATTEMPTS = 5;
+export const CONTACT_BIND_MAX_PENDING_PER_CHANNEL = 100;
+export const CONTACT_BIND_MAX_PENDING_TOTAL = 5_000;
+export const CONTACT_BIND_MAX_INVALID_ACTORS = 1_000;
+/** In-memory, one-time channel identity proof used before writing a Contact alias. */
+export class ContactBindCodeRegistry {
+    options;
+    /** `selfAid + channelName + primaryId` -> pending request. */
+    pendingByPrimary = new Map();
+    /** `selfAid + channelName + code` -> pending request key. */
+    pendingByCode = new Map();
+    /** Scope -> pending request keys, used for bounded cleanup and capacity checks. */
+    pendingKeysByScope = new Map();
+    /** Unknown-code throttling is deliberately separate from any pending request. */
+    invalidAttemptsByActor = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    register(req) {
+        const selfAid = String(req.selfAid || '').trim();
+        const primaryId = String(req.primaryId || '').trim();
+        const now = req.now ?? Date.now();
+        const requestedCode = req.code ? String(req.code).trim() : undefined;
+        if (!isValidAid(selfAid))
+            return { ok: false, error: `invalid selfAid: ${req.selfAid}` };
+        const channelName = normalizeContactChannelKey(selfAid, this.options.channelType, req.channelName);
+        if (!channelName)
+            return { ok: false, error: `invalid channelName: ${req.channelName}` };
+        if (!isValidAid(primaryId))
+            return { ok: false, error: `invalid primaryId: ${req.primaryId}` };
+        const contact = resolveContactView(selfAid, primaryId);
+        if (!contact.isOwner && !isAcceptedContact(selfAid, primaryId)) {
+            return { ok: false, error: `only an active contact or Agent owner can bind an identity: ${primaryId}` };
+        }
+        if (requestedCode && !/^\d{6}$/.test(requestedCode))
+            return { ok: false, error: 'binding code must be 6 digits' };
+        const scope = pendingScopeKey(selfAid, channelName);
+        this.purgeExpiredAll(now);
+        const key = pendingBindKey(selfAid, channelName, primaryId);
+        const replaced = this.pendingByPrimary.has(key);
+        const code = requestedCode ?? this.generateUniqueCode(scope);
+        if (!code)
+            return { ok: false, error: 'unable to allocate a unique binding code' };
+        const codeKey = pendingCodeKey(scope, code);
+        const existingCodeOwner = this.pendingByCode.get(codeKey);
+        if (existingCodeOwner && existingCodeOwner !== key) {
+            return { ok: false, error: 'binding code is already active for this channel instance' };
+        }
+        const pendingInScope = this.pendingKeysByScope.get(scope)?.size ?? 0;
+        if (!replaced && pendingInScope >= CONTACT_BIND_MAX_PENDING_PER_CHANNEL) {
+            return { ok: false, error: 'too many pending binding requests for this channel instance' };
+        }
+        if (!replaced && this.pendingByPrimary.size >= CONTACT_BIND_MAX_PENDING_TOTAL) {
+            return { ok: false, error: 'too many pending binding requests in this process' };
+        }
+        if (replaced)
+            this.removePending(key);
+        const item = {
+            selfAid,
+            channelName,
+            primaryId,
+            code,
+            createdAt: now,
+            expiresAt: now + CONTACT_BIND_CODE_TTL_MS,
+        };
+        this.pendingByPrimary.set(key, item);
+        this.pendingByCode.set(codeKey, key);
+        const scopeKeys = this.pendingKeysByScope.get(scope) ?? new Set();
+        scopeKeys.add(key);
+        this.pendingKeysByScope.set(scope, scopeKeys);
+        return { ok: true, code, expiresAt: item.expiresAt, replaced };
+    }
+    handle(ctx) {
+        if (ctx.channelType !== this.options.channelType)
+            return { handled: false };
+        const selfAid = String(ctx.selfAid || '').trim();
+        const channelName = normalizeContactChannelKey(selfAid, this.options.channelType, ctx.channelName);
+        if (!channelName)
+            return { handled: false };
+        const now = ctx.now ?? Date.now();
+        if (ctx.chatType !== 'private')
+            return { handled: false };
+        const input = String(ctx.content ?? '').trim();
+        const scope = pendingScopeKey(selfAid, channelName);
+        const codeKey = /^\d{6}$/.test(input) ? pendingCodeKey(scope, input) : undefined;
+        const pendingKey = codeKey ? this.pendingByCode.get(codeKey) : undefined;
+        const matchingItem = pendingKey ? this.pendingByPrimary.get(pendingKey) : undefined;
+        if (matchingItem && now >= matchingItem.expiresAt) {
+            this.removePending(pendingKey);
+            return {
+                handled: true,
+                status: 'expired',
+                remainingAttempts: 0,
+                reply: this.expiredReply(),
+            };
+        }
+        this.purgeExpiredAll(now);
+        const hasPending = (this.pendingKeysByScope.get(scope)?.size ?? 0) > 0;
+        if (!hasPending)
+            return { handled: false };
+        if (!/^\d{6}$/.test(input)) {
+            return {
+                handled: true,
+                status: 'format',
+                reply: '请发送 /bind <6 位数字绑定码>。',
+                remainingAttempts: CONTACT_BIND_MAX_FAILED_ATTEMPTS,
+            };
+        }
+        if (!matchingItem) {
+            const invalidAttempt = this.recordInvalidAttempt(scope, String(ctx.actorId || '').trim(), now);
+            if (invalidAttempt.remaining > 0) {
+                return {
+                    handled: true,
+                    status: 'wrong-code',
+                    remainingAttempts: invalidAttempt.remaining,
+                    reply: '绑定码错误，请重新发送 /bind <6 位数字绑定码>。',
+                };
+            }
+            return {
+                handled: true,
+                status: 'rate-limited',
+                remainingAttempts: 0,
+                reply: '绑定码错误次数过多，请稍后再试。有效绑定码仍可直接提交。',
+            };
+        }
+        const actorId = String(ctx.actorId || '').trim();
+        if (!actorId) {
+            return {
+                handled: true,
+                status: 'missing-actor',
+                remainingAttempts: CONTACT_BIND_MAX_FAILED_ATTEMPTS,
+                reply: `无法识别当前${this.options.displayName}发送者身份，未建立绑定。请重新发送绑定码或重新执行绑定流程。`,
+            };
+        }
+        // Claim first. A matching one-time code is never reusable, including when the
+        // final Contact Book validation or write fails.
+        this.removePending(pendingKey);
+        try {
+            const alias = formatContactAlias(matchingItem.channelName, actorId);
+            mutateContactBookSync({
+                selfAid: matchingItem.selfAid,
+                actor: actorId,
+                mutation: { type: 'bind-alias-eligible', primaryId: matchingItem.primaryId, alias },
+            });
+            return {
+                handled: true,
+                status: 'bound',
+                reply: `${this.options.displayName}身份绑定成功：${matchingItem.channelName}:${encodeURIComponent(actorId)} -> ${matchingItem.primaryId}`,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                handled: true,
+                status: 'write-failed',
+                remainingAttempts: CONTACT_BIND_MAX_FAILED_ATTEMPTS,
+                reply: `${this.options.displayName}身份绑定写入失败：${message}`,
+            };
+        }
+    }
+    get(selfAid, channelName, primaryId) {
+        const normalizedSelfAid = String(selfAid || '').trim();
+        const normalizedChannelName = normalizeContactChannelKey(normalizedSelfAid, this.options.channelType, channelName);
+        if (!normalizedChannelName)
+            return null;
+        const scope = pendingScopeKey(normalizedSelfAid, normalizedChannelName);
+        const key = primaryId
+            ? pendingBindKey(normalizedSelfAid, normalizedChannelName, primaryId)
+            : this.pendingKeysByScope.get(scope)?.values().next().value;
+        const item = key ? this.pendingByPrimary.get(key) : undefined;
+        return item ? { ...item } : null;
+    }
+    clear() {
+        this.pendingByPrimary.clear();
+        this.pendingByCode.clear();
+        this.pendingKeysByScope.clear();
+        this.invalidAttemptsByActor.clear();
+    }
+    noPendingReply() {
+        return `当前没有待验证的${this.options.displayName}身份绑定码。请先在目标 Agent 的 AUN 私聊发送 /bind ${this.options.channelType}，或执行 ${this.options.initCommand} 生成新的绑定码。`;
+    }
+    generateUniqueCode(scope) {
+        for (let attempt = 0; attempt < 100; attempt += 1) {
+            const code = generateBindCode();
+            if (!this.pendingByCode.has(pendingCodeKey(scope, code)))
+                return code;
+        }
+        return null;
+    }
+    purgeExpiredAll(now) {
+        for (const [key, item] of this.pendingByPrimary) {
+            if (!item || now >= item.expiresAt)
+                this.removePending(key);
+        }
+    }
+    removePending(key) {
+        const item = this.pendingByPrimary.get(key);
+        if (!item)
+            return;
+        const scope = pendingScopeKey(item.selfAid, item.channelName);
+        this.pendingByPrimary.delete(key);
+        this.pendingByCode.delete(pendingCodeKey(scope, item.code));
+        const scopeKeys = this.pendingKeysByScope.get(scope);
+        scopeKeys?.delete(key);
+        if (scopeKeys?.size === 0)
+            this.pendingKeysByScope.delete(scope);
+    }
+    recordInvalidAttempt(scope, actorId, now) {
+        const key = `${scope}\u0000${actorId || '<unknown>'}`;
+        this.purgeExpiredInvalidAttempts(now);
+        const current = this.invalidAttemptsByActor.get(key);
+        const attempts = current && now < current.expiresAt ? current.attempts + 1 : 1;
+        this.invalidAttemptsByActor.delete(key);
+        if (this.invalidAttemptsByActor.size >= CONTACT_BIND_MAX_INVALID_ACTORS) {
+            const oldestKey = this.invalidAttemptsByActor.keys().next().value;
+            if (oldestKey)
+                this.invalidAttemptsByActor.delete(oldestKey);
+        }
+        this.invalidAttemptsByActor.set(key, { attempts, expiresAt: now + CONTACT_BIND_CODE_TTL_MS });
+        return { remaining: Math.max(0, CONTACT_BIND_MAX_FAILED_ATTEMPTS - attempts) };
+    }
+    purgeExpiredInvalidAttempts(now) {
+        for (const [key, value] of this.invalidAttemptsByActor) {
+            if (now >= value.expiresAt)
+                this.invalidAttemptsByActor.delete(key);
+        }
+    }
+    expiredReply() {
+        return `${this.options.displayName}身份绑定码已超时。请重新在 AUN 私聊目标 Agent 发送 /bind ${this.options.channelType}，或执行 ${this.options.initCommand} 并再次绑定。`;
+    }
+}
+/**
+ * Reserve `/bind` for channel identity binding so it is never treated as an
+ * ordinary chat message. A pending request determines whether the command can
+ * complete a binding; otherwise the user receives setup guidance.
+ */
+export function handleExplicitContactBindCommand(registry, ctx) {
+    const match = /^\s*\/bind(?:\s+(.+?))?\s*$/i.exec(String(ctx.content ?? ''));
+    if (!match)
+        return { handled: false };
+    if (ctx.chatType !== 'private') {
+        return {
+            handled: true,
+            status: 'private-only',
+            reply: '身份绑定仅支持私聊机器人。请在私聊中发送 /bind <6 位数字绑定码>。',
+        };
+    }
+    const result = registry.handle({ ...ctx, content: match[1] ?? '' });
+    if (result.handled)
+        return result;
+    return {
+        handled: true,
+        status: 'no-pending',
+        reply: registry.noPendingReply(),
+    };
+}
+function generateBindCode() {
+    return String(randomInt(0, 1_000_000)).padStart(6, '0');
+}
+function pendingScopeKey(selfAid, channelName) {
+    return `${String(selfAid || '').trim()}\u0000${String(channelName || '').trim()}`;
+}
+function pendingBindKey(selfAid, channelName, primaryId) {
+    return `${pendingScopeKey(selfAid, channelName)}\u0000${String(primaryId || '').trim()}`;
+}
+function pendingCodeKey(scope, code) {
+    return `${scope}\u0000${code}`;
+}