evolcore 0.0.1 → 0.0.2

package/dist/eck/group-rules-sync.js

@@ -0,0 +1,345 @@
+import fs from 'fs';
+import path from 'path';
+import { createHash } from 'crypto';
+import { TextDecoder } from 'util';
+import { getAidStore, isValidAid, loadClient, SLOT } from '../aun/aid/index.js';
+import { checkGroupIndex as checkGroupIndexRpc, getGroupIndex as getGroupIndexRpc } from '../aun/msg/group-index.js';
+import { agentRelationsDir } from '../paths.js';
+import { formatPeerKey } from '../core/relation/peer-identity.js';
+import { atomicWriteBytes } from '../utils/atomic-write.js';
+import { logger } from '../utils/logger.js';
+import { invalidateKitCache } from './kit-renderer.js';
+const RULES_REMOTE_PATH = '/rules.md';
+const RULES_LOCAL_PATH = 'rules.md';
+// Keep group rules aligned with AUN agent.md: an entry document, not a knowledge base.
+const MAX_RULES_BYTES = 4 * 1024;
+const MTIME_TOLERANCE_MS = 1;
+export async function syncGroupRulesContext(opts) {
+    const { selfAid, groupId, channel } = opts;
+    if (!selfAid || !groupId || !isValidAid(selfAid))
+        return {};
+    const paths = relationPaths(selfAid, channel, groupId);
+    fs.mkdirSync(paths.dir, { recursive: true });
+    const group = lazyGroupClient(selfAid);
+    try {
+        const resolved = await resolveGroupRules(group.client, groupId, paths.localRulesPath);
+        if (resolved.changed)
+            invalidateKitCache();
+        return {
+            groupRulesPath: resolved.usable ? paths.localRulesPath : undefined,
+            groupRulesStatus: resolved.status,
+            groupRulesError: resolved.error,
+        };
+    }
+    catch (e) {
+        const status = classifyError(e);
+        const error = errorMessage(e);
+        logger.warn(`[GroupRulesSync] ${groupId} rules sync failed: ${error}`);
+        return {
+            groupRulesStatus: status,
+            groupRulesError: error,
+        };
+    }
+    finally {
+        await group.close();
+    }
+}
+async function resolveGroupRules(clientPromise, groupId, localPath) {
+    const client = await clientPromise();
+    const check = await safeCheckGroupIndex(client, groupId);
+    const shouldPull = check === null || check.needs_update === true || check.local_found !== true;
+    const rulesContent = await getRulesContent(client, groupId, shouldPull);
+    const rawContent = rulesContent.content;
+    if (rawContent === undefined || rawContent === null || rawContent === '') {
+        return { status: 'missing', usable: false, changed: false };
+    }
+    const metadata = parseRulesMetadata(rawContent);
+    if (metadata.size > MAX_RULES_BYTES) {
+        return { status: 'too_large', usable: false, changed: false, error: `群规则过大: ${metadata.size} bytes > ${MAX_RULES_BYTES}` };
+    }
+    const remoteRefValue = `${rulesContent.groupAid || groupId}:${RULES_REMOTE_PATH}`;
+    const remoteNode = normalizeRemoteRulesNode(await client.group.fs.stat(remoteRefValue));
+    if (!remoteNode.size || remoteNode.mtimeMs === undefined) {
+        return {
+            status: 'unreadable',
+            usable: false,
+            changed: false,
+            error: `远端规则文件缺少 size 或 mtimeMs: ${remoteRefValue}`,
+        };
+    }
+    if (!metadataMatchesNode(metadata, remoteNode)) {
+        return {
+            status: 'file_mismatch',
+            usable: false,
+            changed: false,
+            error: `远端 /rules.md 与 rules.content 不匹配: expected size=${metadata.size} mtimeMs=${metadata.mtimeMs}, actual size=${remoteNode.size} mtimeMs=${remoteNode.mtimeMs}`,
+        };
+    }
+    if (localMaterializationMatches(localPath, metadata)) {
+        return { status: rulesContent.pulled ? 'synced' : 'cached', usable: true, changed: false };
+    }
+    const bytes = await downloadGroupFileBytes(client, remoteRefValue);
+    if (bytes.byteLength > MAX_RULES_BYTES) {
+        return { status: 'too_large', usable: false, changed: false, error: `群规则过大: ${bytes.byteLength} bytes > ${MAX_RULES_BYTES}` };
+    }
+    if (bytes.byteLength !== metadata.size) {
+        return {
+            status: 'file_mismatch',
+            usable: false,
+            changed: false,
+            error: `下载后的 /rules.md 与 rules.content 大小不匹配: expected ${metadata.size}, actual ${bytes.byteLength}`,
+        };
+    }
+    try {
+        assertUtf8(bytes);
+    }
+    catch (e) {
+        return {
+            status: 'unreadable',
+            usable: false,
+            changed: false,
+            error: `远端 /rules.md 不是有效 UTF-8: ${errorMessage(e)}`,
+        };
+    }
+    const previousMatches = localMaterializationMatches(localPath, metadata);
+    atomicWriteBytes(localPath, bytes);
+    const mtimeSeconds = metadata.mtimeMs / 1000;
+    fs.utimesSync(localPath, mtimeSeconds, mtimeSeconds);
+    if (!localMaterializationMatches(localPath, metadata)) {
+        return {
+            status: 'error',
+            usable: false,
+            changed: false,
+            error: `本地物化文件 stat 与 rules.content 不匹配: ${localPath}`,
+        };
+    }
+    return { status: 'synced', usable: true, changed: !previousMatches };
+}
+async function safeCheckGroupIndex(client, groupId) {
+    try {
+        return await checkGroupIndexRpc(client, groupId);
+    }
+    catch (e) {
+        logger.debug(`[GroupRulesSync] checkGroupIndex ignored for ${groupId}: ${errorMessage(e)}`);
+        return null;
+    }
+}
+async function getGroupIndex(client, groupId) {
+    const result = await getGroupIndexRpc(client, groupId);
+    return {
+        group_aid: typeof result.group_aid === 'string' ? result.group_aid : groupId,
+        meta: isRecord(result.meta) ? result.meta : undefined,
+        settings: isRecord(result.settings) ? result.settings : {},
+    };
+}
+async function getRulesContent(client, groupId, forcePull) {
+    if (forcePull) {
+        const index = await getGroupIndex(client, groupId);
+        return {
+            groupAid: index.group_aid || groupId,
+            content: index.settings?.['rules.content'],
+            pulled: true,
+        };
+    }
+    try {
+        const result = await client.group.getRules({ group_id: groupId });
+        const rules = isRecord(result.rules) ? result.rules : {};
+        return {
+            groupAid: typeof result.group_id === 'string' ? result.group_id : groupId,
+            content: rules.content,
+            pulled: false,
+        };
+    }
+    catch (e) {
+        logger.debug(`[GroupRulesSync] getRules fallback to getGroupIndex for ${groupId}: ${errorMessage(e)}`);
+        const index = await getGroupIndex(client, groupId);
+        return {
+            groupAid: index.group_aid || groupId,
+            content: index.settings?.['rules.content'],
+            pulled: true,
+        };
+    }
+}
+function parseRulesMetadata(value) {
+    let parsed;
+    if (typeof value === 'string') {
+        try {
+            parsed = JSON.parse(value);
+        }
+        catch {
+            throw statusError('invalid_metadata', 'rules.content 不是合法 JSON');
+        }
+    }
+    else {
+        parsed = value;
+    }
+    if (!isRecord(parsed)) {
+        throw statusError('invalid_metadata', 'rules.content 必须是对象');
+    }
+    if (parsed.path !== RULES_REMOTE_PATH) {
+        throw statusError('invalid_metadata', `rules.content.path 必须是 ${RULES_REMOTE_PATH}`);
+    }
+    const size = numberField(parsed, ['size']);
+    const mtimeMs = mtimeMsField(parsed);
+    if (size === undefined || !Number.isInteger(size) || size <= 0) {
+        throw statusError('invalid_metadata', 'rules.content.size 必须是正整数');
+    }
+    if (mtimeMs === undefined || !Number.isFinite(mtimeMs) || mtimeMs <= 0) {
+        throw statusError('invalid_metadata', 'rules.content.mtimeMs 必须是有效毫秒时间戳');
+    }
+    return { path: RULES_REMOTE_PATH, size, mtimeMs };
+}
+function normalizeRemoteRulesNode(value) {
+    if (!isRecord(value))
+        return {};
+    return {
+        size: numberField(value, ['size', 'sizeBytes', 'size_bytes', 'bytes']),
+        mtimeMs: mtimeMsField(value),
+    };
+}
+function metadataMatchesNode(metadata, node) {
+    return node.size === metadata.size
+        && node.mtimeMs !== undefined
+        && Math.abs(node.mtimeMs - metadata.mtimeMs) <= MTIME_TOLERANCE_MS;
+}
+function localMaterializationMatches(localPath, metadata) {
+    try {
+        const st = fs.statSync(localPath);
+        return st.isFile()
+            && st.size === metadata.size
+            && Math.abs(st.mtimeMs - metadata.mtimeMs) <= MTIME_TOLERANCE_MS;
+    }
+    catch {
+        return false;
+    }
+}
+function lazyGroupClient(selfAid) {
+    let client;
+    let store;
+    return {
+        client: async () => {
+            if (client)
+                return client;
+            store = await getAidStore({ slotId: SLOT.daemon });
+            client = await loadClient(store, selfAid);
+            await client.connect({ connection_kind: 'short', short_ttl_ms: 30000, auto_reconnect: false });
+            return client;
+        },
+        close: async () => {
+            if (client) {
+                try {
+                    await client.close();
+                }
+                catch { /* ignore */ }
+            }
+            if (store) {
+                try {
+                    store.close();
+                }
+                catch { /* ignore */ }
+            }
+        },
+    };
+}
+async function downloadGroupFileBytes(client, remoteRef) {
+    const ticket = await client.call('group.fs.create_download_ticket', { path: remoteRef });
+    if (!isRecord(ticket)) {
+        throw statusError('unreadable', 'group.fs.create_download_ticket returned invalid response');
+    }
+    const downloadUrl = stringField(ticket, ['download_url', 'url']);
+    if (!downloadUrl) {
+        throw statusError('unreadable', 'group.fs.create_download_ticket did not return download_url');
+    }
+    const bytes = await client.group.fs.lowlevel.httpGet(downloadUrl, bearerHeaders(client));
+    const expectedSha = stringField(ticket, ['sha256']);
+    if (expectedSha && sha256Hex(bytes).toLowerCase() !== expectedSha.toLowerCase()) {
+        throw statusError('unreadable', 'download hash verification failed');
+    }
+    return bytes;
+}
+function sha256Hex(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+function bearerHeaders(client) {
+    const token = accessTokenFromClient(client);
+    return token ? { Authorization: `Bearer ${token}` } : undefined;
+}
+function accessTokenFromClient(client) {
+    const anyClient = client;
+    if (typeof anyClient.getAccessToken === 'function') {
+        const token = stringValue(anyClient.getAccessToken());
+        if (token)
+            return token;
+    }
+    return stringValue(anyClient.accessToken)
+        || stringValue(anyClient.access_token)
+        || stringValue(anyClient._identity?.access_token)
+        || stringValue(anyClient._sessionParams?.access_token);
+}
+function assertUtf8(bytes) {
+    new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+}
+function relationPaths(selfAid, channel, groupId) {
+    const peerKey = formatPeerKey(channel, groupId);
+    const dir = path.join(agentRelationsDir(selfAid), peerKey);
+    return {
+        peerKey,
+        dir,
+        localRulesPath: path.join(dir, RULES_LOCAL_PATH),
+    };
+}
+class StatusError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+function statusError(status, message) {
+    return new StatusError(status, message);
+}
+function classifyError(e) {
+    if (e instanceof StatusError)
+        return e.status;
+    const msg = errorMessage(e).toLowerCase();
+    if (msg.includes('forbidden') || msg.includes('unauthorized') || msg.includes('permission'))
+        return 'forbidden';
+    if (msg.includes('not found') || msg.includes('does not exist'))
+        return 'missing';
+    return 'error';
+}
+function errorMessage(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+function isRecord(x) {
+    return typeof x === 'object' && x !== null && !Array.isArray(x);
+}
+function stringValue(x) {
+    return typeof x === 'string' ? x : '';
+}
+function stringField(obj, keys) {
+    for (const k of keys) {
+        const v = obj[k];
+        if (typeof v === 'string')
+            return v;
+    }
+    return undefined;
+}
+function numberField(obj, keys) {
+    for (const k of keys) {
+        const v = obj[k];
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+    }
+    return undefined;
+}
+function mtimeMsField(obj) {
+    const candidates = ['mtimeMs', 'mtime_ms', 'mtimeMillis', 'mtime'];
+    for (const k of candidates) {
+        const v = obj[k];
+        if (typeof v === 'number' && Number.isFinite(v)) {
+            return k === 'mtime' && v < 1e12 ? v * 1000 : v;
+        }
+    }
+    return undefined;
+}

package/dist/eck/init.js

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths, kitsDocsDir, agentDir, getPackageRoot } from '../paths.js';
+import { atomicWriteText } from '../utils/atomic-write.js';
+import { logger } from '../utils/logger.js';
+export function initEck() {
+    const p = resolvePaths();
+    const eckDir = p.eckDir;
+    fs.mkdirSync(eckDir, { recursive: true });
+    initEckRuntime(eckDir);
+    initEckPathRegistry(eckDir);
+}
+export function initAgentIndex(aid) {
+    const indexDir = path.join(agentDir(aid), 'index');
+    fs.mkdirSync(indexDir, { recursive: true });
+    const indexFile = path.join(indexDir, 'INDEX.md');
+    const guideFile = path.join(indexDir, 'GUIDE.md');
+    if (!fs.existsSync(indexFile)) {
+        const template = loadTemplate('INDEX.template.md');
+        if (template) {
+            atomicWriteText(indexFile, renderTemplate(template, { AID: aid }));
+            logger.info(`[eck] Created ${indexFile}`);
+        }
+    }
+    if (!fs.existsSync(guideFile)) {
+        const template = loadTemplate('GUIDE.template.md');
+        if (template) {
+            atomicWriteText(guideFile, renderTemplate(template, { AID: aid }));
+            logger.info(`[eck] Created ${guideFile}`);
+        }
+    }
+}
+function initEckRuntime(eckDir) {
+    const runtimeFile = path.join(eckDir, 'runtime.md');
+    if (fs.existsSync(runtimeFile))
+        return;
+    const template = loadTemplate('runtime.template.md');
+    if (!template)
+        return;
+    const vars = {
+        EVOLCORE_HOME: resolvePaths().root,
+        PACKAGE_ROOT: getPackageRoot(),
+    };
+    atomicWriteText(runtimeFile, renderTemplate(template, vars));
+    logger.info(`[eck] Created ${runtimeFile}`);
+}
+function initEckPathRegistry(eckDir) {
+    const registryFile = path.join(eckDir, 'path-registry.md');
+    if (fs.existsSync(registryFile))
+        return;
+    const template = loadTemplate('path-registry.template.md');
+    if (!template)
+        return;
+    const vars = {
+        EVOLCORE_HOME: resolvePaths().root,
+        PACKAGE_ROOT: getPackageRoot(),
+    };
+    atomicWriteText(registryFile, renderTemplate(template, vars));
+    logger.info(`[eck] Created ${registryFile}`);
+}
+function loadTemplate(filename) {
+    const templatePath = path.join(kitsDocsDir(), 'eck_templates', filename);
+    try {
+        return fs.readFileSync(templatePath, 'utf-8');
+    }
+    catch {
+        logger.warn(`[eck] Template not found: ${templatePath}`);
+        return null;
+    }
+}
+function renderTemplate(template, vars) {
+    let result = template;
+    for (const [key, value] of Object.entries(vars)) {
+        result = result.replaceAll(`{{${key}}}`, value);
+    }
+    return result;
+}