evolcore 0.0.1 → 0.0.3

package/dist/utils/aid-bind.js

@@ -0,0 +1,313 @@
+import crypto from 'crypto';
+import { loadAgent, loadDaemonConfig, saveAgent, saveDaemonConfig } from '../config-store.js';
+import { resolveEffective } from '../config/config-manager.js';
+import { readEvolcoreVersion } from '../index.js';
+export class BindService {
+    opts;
+    tasks = new Map();
+    taskIdsByTokenHash = new Map();
+    cleanupTimer = null;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    startCleanup() {
+        if (this.cleanupTimer)
+            return;
+        this.cleanupTimer = setInterval(() => this.cleanup(), 60_000);
+        this.cleanupTimer.unref?.();
+    }
+    stopCleanup() {
+        if (!this.cleanupTimer)
+            return;
+        clearInterval(this.cleanupTimer);
+        this.cleanupTimer = null;
+    }
+    begin(req) {
+        if (req.bindType !== 'daemon' && req.bindType !== 'agent') {
+            return { ok: false, code: 'INVALID_BIND_TYPE', error: 'invalid bindType' };
+        }
+        const targetAid = req.bindType === 'daemon' ? (req.targetAid ?? this.opts.receiverAid) : req.targetAid;
+        if (!targetAid || typeof targetAid !== 'string') {
+            return { ok: false, code: 'MISSING_TARGET', error: 'missing targetAid' };
+        }
+        if (req.bindType === 'daemon' && targetAid !== this.opts.receiverAid) {
+            return { ok: false, code: 'TARGET_MISMATCH', error: 'daemon targetAid must equal control AID' };
+        }
+        if (req.bindType === 'agent' && !loadAgent(targetAid)) {
+            return { ok: false, code: 'TARGET_NOT_FOUND', error: `agent not found: ${targetAid}` };
+        }
+        const taskId = crypto.randomUUID();
+        let token = generatePublicToken();
+        let tokenHash = hashToken(token);
+        while (this.taskIdsByTokenHash.has(tokenHash)) {
+            token = generatePublicToken();
+            tokenHash = hashToken(token);
+        }
+        const ttlMs = clampTtl(req.ttlMs);
+        const expiresAt = Date.now() + ttlMs;
+        const ownerMode = req.ownerMode === 'replace' ? 'replace' : 'append';
+        const task = {
+            taskId,
+            bindType: req.bindType,
+            receiverAid: this.opts.receiverAid,
+            targetAid,
+            agentName: req.agentName,
+            tokenHash,
+            createdAt: Date.now(),
+            expiresAt,
+            status: 'pending',
+            ownerMode,
+        };
+        this.tasks.set(taskId, task);
+        this.taskIdsByTokenHash.set(tokenHash, taskId);
+        this.cleanup();
+        return {
+            ok: true,
+            taskId,
+            expiresAt,
+            qrData: {
+                type: 'evolcore.bind',
+                version: readEvolcoreVersion(),
+                bindType: req.bindType,
+                daemonAid: this.opts.receiverAid,
+                ...(req.bindType === 'daemon' ? { platform: getPlatform() } : {}),
+                ...(req.bindType === 'agent' ? { agentAid: targetAid, agentName: req.agentName ?? null } : {}),
+                token,
+                expiresAt,
+            },
+        };
+    }
+    status(taskId) {
+        if (!taskId)
+            return { ok: false, code: 'MISSING_TASK', error: 'missing taskId' };
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return { ok: false, code: 'TASK_NOT_FOUND', error: 'binding task not found' };
+        if (task.status === 'pending' && Date.now() > task.expiresAt) {
+            task.status = 'expired';
+            task.finishedAt ??= task.expiresAt;
+        }
+        return {
+            ok: true,
+            taskId: task.taskId,
+            status: task.status,
+            boundAid: task.boundAid,
+            boundName: task.boundName,
+        };
+    }
+    cancel(taskId) {
+        if (!taskId)
+            return { ok: false, code: 'MISSING_TASK', error: 'missing taskId' };
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return { ok: false, code: 'TASK_NOT_FOUND', error: 'binding task not found' };
+        if (task.status === 'pending') {
+            task.status = 'cancelled';
+            task.finishedAt = Date.now();
+        }
+        return {
+            ok: true,
+            taskId: task.taskId,
+            status: task.status,
+            boundAid: task.boundAid,
+            boundName: task.boundName,
+        };
+    }
+    async handleRequest(payload, fromAid) {
+        if (payload?.type !== 'bind.request')
+            return null;
+        const bindType = payload.bindType === 'agent' ? 'agent' : 'daemon';
+        const fail = (code, message) => ({
+            type: 'bind.response',
+            bindType,
+            success: false,
+            error: { code, message },
+        });
+        if (!payload.token)
+            return fail('INVALID_TOKEN', 'invalid token');
+        const taskId = this.taskIdsByTokenHash.get(hashToken(payload.token));
+        if (!taskId)
+            return fail('TASK_NOT_FOUND', 'binding task not found');
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return fail('TASK_NOT_FOUND', 'binding task not found');
+        if (payload.bindType !== task.bindType)
+            return fail('BIND_TYPE_MISMATCH', 'bindType mismatch');
+        if (!fromAid)
+            return fail('INTERNAL_ERROR', 'missing AUN sender');
+        if (task.status === 'pending' && Date.now() > task.expiresAt) {
+            task.status = 'expired';
+            task.finishedAt ??= task.expiresAt;
+            return fail('TASK_EXPIRED', 'binding task expired');
+        }
+        if (task.status === 'bound') {
+            // The owner write and task transition necessarily happen before the caller
+            // can send bind.response. If that send fails, the App retries the same
+            // authenticated request. Replay the original success only to the AID that
+            // completed the bind; other senders must not receive daemonInfo.
+            if (task.boundAid === fromAid && task.boundResponse)
+                return task.boundResponse;
+            return fail('ALREADY_BOUND', 'binding task already completed');
+        }
+        if (task.status !== 'pending')
+            return fail('TASK_NOT_FOUND', 'binding task is not pending');
+        if (!timingSafeTokenEqual(payload.token, task.tokenHash)) {
+            return fail('INVALID_TOKEN', 'invalid token');
+        }
+        try {
+            // Build and retain the exact response before committing the bind so a
+            // post-commit transport failure can be recovered by an idempotent retry.
+            const response = this.buildSuccessResponse(task);
+            this.applyOwnerBinding(task, fromAid);
+            task.status = 'bound';
+            task.boundAid = fromAid;
+            task.boundName = payload.clientName;
+            task.boundResponse = response;
+            task.finishedAt = Date.now();
+            return response;
+        }
+        catch (e) {
+            return fail('INTERNAL_ERROR', e?.message || String(e));
+        }
+    }
+    buildSuccessResponse(task) {
+        const details = task.bindType === 'agent' ? this.buildAgentBindDetails(task) : null;
+        return {
+            type: 'bind.response',
+            bindType: task.bindType,
+            success: true,
+            daemonInfo: {
+                daemonAid: task.receiverAid,
+                ...(task.bindType === 'agent' ? { agentAid: task.targetAid } : {}),
+                bindType: task.bindType,
+                ...(task.bindType === 'daemon'
+                    ? {
+                        version: readEvolcoreVersion(),
+                        platform: getPlatform(),
+                        uptime: this.opts.getUptimeSeconds(),
+                        baseagents: this.opts.getAvailableBaseagents(),
+                    }
+                    : {
+                        active_baseagent: details.baseagent.active_baseagent,
+                        model: details.baseagent.model,
+                        effort: details.baseagent.effort,
+                        channels: details.channels,
+                        agentName: task.agentName,
+                    }),
+            },
+        };
+    }
+    buildAgentBindDetails(task) {
+        const agent = loadAgent(task.targetAid);
+        const config = resolveEffective({ self: task.targetAid }, { expand: true });
+        return {
+            baseagent: resolveBaseagentInfo(config),
+            channels: summarizeChannels(agent?.channels ?? []),
+        };
+    }
+    applyOwnerBinding(task, ownerAid) {
+        if (task.bindType === 'daemon') {
+            const cfg = loadDaemonConfig();
+            const current = cfg.owners ?? [];
+            const owners = task.ownerMode === 'replace'
+                ? [ownerAid]
+                : [ownerAid, ...current.filter(o => o !== ownerAid)];
+            saveDaemonConfig({ ...cfg, $schema_version: cfg.$schema_version ?? 1, owners });
+            this.opts.onDaemonOwnersUpdated?.(owners);
+            return;
+        }
+        const agent = loadAgent(task.targetAid);
+        if (!agent)
+            throw new Error(`agent not found: ${task.targetAid}`);
+        const current = agent.owners ?? [];
+        const owners = task.ownerMode === 'replace'
+            ? [ownerAid]
+            : [ownerAid, ...current.filter(o => o !== ownerAid)];
+        saveAgent({ ...agent, owners });
+    }
+    cleanup() {
+        const now = Date.now();
+        for (const [id, task] of this.tasks) {
+            if (task.status === 'pending' && now > task.expiresAt) {
+                task.status = 'expired';
+                task.finishedAt ??= task.expiresAt;
+            }
+            if (task.status === 'cancelled') {
+                this.deleteTask(id);
+            }
+            else if (task.status === 'expired' && now - (task.finishedAt ?? task.expiresAt) > 10 * 60_000) {
+                this.deleteTask(id);
+            }
+            else if (task.status === 'bound' && task.finishedAt && now - task.finishedAt > 10 * 60_000) {
+                this.deleteTask(id);
+            }
+        }
+        if (this.tasks.size <= 128)
+            return;
+        const sorted = [...this.tasks.values()].sort((a, b) => a.createdAt - b.createdAt);
+        for (const task of sorted) {
+            if (this.tasks.size <= 128)
+                break;
+            if (task.status !== 'pending')
+                this.deleteTask(task.taskId);
+        }
+    }
+    deleteTask(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return;
+        this.tasks.delete(taskId);
+        this.taskIdsByTokenHash.delete(task.tokenHash);
+    }
+}
+function clampTtl(ttlMs) {
+    if (!ttlMs || !Number.isFinite(ttlMs))
+        return 10 * 60_000;
+    return Math.max(60_000, Math.min(ttlMs, 10 * 60_000));
+}
+function hashToken(token) {
+    return crypto.createHash('sha256').update(token, 'utf8').digest('hex');
+}
+function generatePublicToken() {
+    return crypto.randomBytes(16).toString('base64url'); // 128 bits for stronger security
+}
+function timingSafeTokenEqual(token, expectedHash) {
+    const actual = Buffer.from(hashToken(token), 'hex');
+    const expected = Buffer.from(expectedHash, 'hex');
+    if (actual.length !== expected.length)
+        return false;
+    return crypto.timingSafeEqual(actual, expected);
+}
+function resolveBaseagentInfo(config) {
+    const baseagents = (config?.baseagents ?? {});
+    const active_baseagent = ('active_baseagent' in (config ?? {}) && typeof config?.active_baseagent === 'string')
+        ? config.active_baseagent
+        : pickFirstBaseagent(baseagents);
+    const block = active_baseagent ? baseagents[active_baseagent] : undefined;
+    const model = typeof block?.model === 'string' ? block.model : undefined;
+    const effort = typeof block?.effort === 'string'
+        ? block.effort
+        : (typeof block?.reasoning === 'string' ? block.reasoning : undefined);
+    return { active_baseagent, model, effort };
+}
+function pickFirstBaseagent(baseagents) {
+    for (const name of ['claude', 'codex', 'gemini']) {
+        if (baseagents[name] !== undefined)
+            return name;
+    }
+    return 'claude';
+}
+function summarizeChannels(channels) {
+    return channels.map(ch => ({
+        type: ch.type,
+        name: ch.name,
+        enabled: ch.enabled !== false,
+    }));
+}
+function getPlatform() {
+    if (process.platform === 'win32')
+        return 'windows';
+    if (process.platform === 'darwin')
+        return 'macos';
+    return 'linux';
+}

package/dist/utils/atomic-write.js

@@ -0,0 +1,95 @@
+/**
+ * Atomic write via dual rename.
+ *
+ * 写入流程（写 foo.json）：
+ *   1. 把当前 foo.json 改名为 foo.json_   （保留旧版作为热备）
+ *   2. 把新内容写到 foo.json__            （写入完成才有完整内容）
+ *   3. 把 foo.json__ rename 为 foo.json   （原子切换）
+ *   foo.json_ 留到下次写入时被覆盖。
+ *
+ * 读取时按以下顺序探测，自动恢复中途崩溃的状态：
+ *   - foo.json__ 存在 → 上次写入未完成，丢弃
+ *   - foo.json    存在 → 直接读
+ *   - foo.json_   存在 → rename 步骤崩溃，rename 回 foo.json 再读
+ *   - 都不存在 → null
+ */
+import fs from 'fs';
+import path from 'path';
+const HOT = '_'; // foo.json_   旧版热备
+const TMP = '__'; // foo.json__  写入中
+/**
+ * 原子写入 JSON 文件（双 rename）。dirname 不存在时会自动创建。
+ *
+ * @param filePath 目标文件
+ * @param content 完整内容（不含末尾换行也可，由调用方控制）
+ */
+export function atomicWrite(filePath, content) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const hot = filePath + HOT;
+    const tmp = filePath + TMP;
+    // 步骤 1：当前文件 → hot（保留旧版作热备）
+    if (fs.existsSync(filePath)) {
+        if (fs.existsSync(hot))
+            fs.unlinkSync(hot);
+        fs.renameSync(filePath, hot);
+    }
+    // 步骤 2：写到 tmp
+    fs.writeFileSync(tmp, content, 'utf-8');
+    // 步骤 3：tmp → 目标（原子）
+    fs.renameSync(tmp, filePath);
+}
+export function atomicWriteJson(filePath, value) {
+    atomicWrite(filePath, JSON.stringify(value, null, 2) + '\n');
+}
+/**
+ * 原子读取——自动按状态恢复。文件不存在时返回 null。
+ *
+ * 调用方拿到 null 应当作"文件不存在"处理；解析失败抛错。
+ */
+export function atomicRead(filePath) {
+    const hot = filePath + HOT;
+    const tmp = filePath + TMP;
+    // 中途崩溃残留 → 丢弃
+    if (fs.existsSync(tmp)) {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch { /* best effort */ }
+    }
+    if (fs.existsSync(filePath)) {
+        return fs.readFileSync(filePath, 'utf-8');
+    }
+    // rename 步骤崩溃 → 把 hot 移回正式名
+    if (fs.existsSync(hot)) {
+        fs.renameSync(hot, filePath);
+        return fs.readFileSync(filePath, 'utf-8');
+    }
+    return null;
+}
+export function atomicReadJson(filePath) {
+    const text = atomicRead(filePath);
+    if (text === null)
+        return null;
+    return JSON.parse(text);
+}
+export function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+/**
+ * Simple atomic write for plain-text files (ECK runtime files).
+ * Uses write-tmp-then-rename (no hot-backup needed for these files).
+ */
+export function atomicWriteText(filePath, content) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmp = filePath + '.tmp.' + process.pid;
+    fs.writeFileSync(tmp, content, 'utf-8');
+    fs.renameSync(tmp, filePath);
+}
+export function atomicWriteBytes(filePath, content) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmp = filePath + '.tmp.' + process.pid;
+    fs.writeFileSync(tmp, content);
+    fs.renameSync(tmp, filePath);
+}

package/dist/utils/avatar-upload.js

@@ -0,0 +1,123 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import crypto from 'crypto';
+import { agentmdGet, agentmdPut, updateAgentMdFrontmatterAvatar } from '../aun/aid/agentmd.js';
+import { storageRm, storageUpload } from '../aun/storage/index.js';
+import { logger } from './logger.js';
+import { validateImage } from './media-cache.js';
+const MAX_AVATAR_BYTES = 500 * 1024;
+const ALLOWED_AVATAR_MIMES = new Set(['image/png', 'image/jpeg', 'image/webp']);
+const MIME_EXT = {
+    'image/png': 'png',
+    'image/jpeg': 'jpg',
+    'image/webp': 'webp',
+};
+function fail(error, code) {
+    return { ok: false, error, code };
+}
+function messageOf(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+function classifyAgentMdReadError(e) {
+    return /not found|404|不存在/i.test(messageOf(e)) ? 'NOT_FOUND' : 'UPLOAD_FAILED';
+}
+function estimateDecodedBytes(base64) {
+    const padding = base64.endsWith('==') ? 2 : base64.endsWith('=') ? 1 : 0;
+    return Math.floor((base64.length * 3) / 4) - padding;
+}
+function formatKb(bytes) {
+    return `${Math.ceil(bytes / 1024)}KB`;
+}
+function parseAvatarDataUrl(dataUrl) {
+    if (typeof dataUrl !== 'string') {
+        return fail('avatar 必须是 data URL 字符串', 'INVALID_ARGS');
+    }
+    const match = dataUrl.match(/^data:(image\/(?:png|jpeg|webp));base64,([\s\S]+)$/);
+    if (!match) {
+        return fail('avatar 格式错误：必须是 data:image/(png|jpeg|webp);base64,', 'INVALID_ARGS');
+    }
+    const declaredMime = match[1];
+    const base64 = match[2].replace(/\s+/g, '');
+    if (!base64 || !/^[A-Za-z0-9+/]+={0,2}$/.test(base64) || base64.length % 4 !== 0) {
+        return fail('avatar base64 编码无效', 'INVALID_ARGS');
+    }
+    const estimatedSize = estimateDecodedBytes(base64);
+    if (estimatedSize > MAX_AVATAR_BYTES) {
+        return fail(`头像大小超过 500KB 限制（当前: ${formatKb(estimatedSize)}）`, 'INVALID_ARGS');
+    }
+    const buffer = Buffer.from(base64, 'base64');
+    if (buffer.length > MAX_AVATAR_BYTES) {
+        return fail(`头像大小超过 500KB 限制（当前: ${formatKb(buffer.length)}）`, 'INVALID_ARGS');
+    }
+    return { mime: declaredMime, buffer };
+}
+async function cleanupUploadedAvatar(aid, objectKey, aunPath) {
+    try {
+        await storageRm(aid, objectKey, { aunPath });
+    }
+    catch (e) {
+        logger.warn(`[avatar-upload] cleanup failed for ${aid}/${objectKey}: ${messageOf(e)}`);
+    }
+}
+export async function uploadAvatar(aid, dataUrl, opts) {
+    const parsed = parseAvatarDataUrl(dataUrl);
+    if ('ok' in parsed)
+        return parsed;
+    const validated = await validateImage(parsed.buffer, {
+        maxSize: MAX_AVATAR_BYTES,
+        allowedMimes: ALLOWED_AVATAR_MIMES,
+    });
+    if (validated.mime === null) {
+        return fail(`头像格式验证失败：${validated.reason}`, 'INVALID_ARGS');
+    }
+    if (validated.mime !== parsed.mime) {
+        return fail(`头像格式验证失败：声明 ${parsed.mime}，实际 ${validated.mime}`, 'INVALID_ARGS');
+    }
+    let agentMd;
+    try {
+        agentMd = await agentmdGet(aid, { aunPath: opts?.aunPath });
+    }
+    catch (e) {
+        return fail(`agent.md 不存在或无法读取: ${messageOf(e)}`, classifyAgentMdReadError(e));
+    }
+    const ext = MIME_EXT[validated.mime] ?? 'img';
+    const objectKey = `shared/avatars/${crypto.randomUUID()}.${ext}`;
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'evolcore-avatar-'));
+    const tmpPath = path.join(tmpDir, `avatar.${ext}`);
+    let uploaded = false;
+    try {
+        fs.writeFileSync(tmpPath, parsed.buffer);
+        const uploadedAvatar = await storageUpload(aid, tmpPath, objectKey, {
+            isPublic: true,
+            contentType: validated.mime,
+            aunPath: opts?.aunPath,
+        });
+        if (!uploadedAvatar.ok) {
+            return fail(`上传到 AUN storage 失败: ${uploadedAvatar.error || 'unknown error'}`, 'UPLOAD_FAILED');
+        }
+        uploaded = true;
+        const publicUrl = uploadedAvatar.publicUrl ?? `https://${aid}/${uploadedAvatar.objectKey}`;
+        const updated = updateAgentMdFrontmatterAvatar(agentMd, publicUrl);
+        try {
+            await agentmdPut(updated.content, { aid, aunPath: opts?.aunPath });
+        }
+        catch (e) {
+            await cleanupUploadedAvatar(aid, uploadedAvatar.objectKey, opts?.aunPath);
+            return fail(`更新 agent.md 失败: ${messageOf(e)}`, 'UPLOAD_FAILED');
+        }
+        logger.info(`[avatar-upload] uploaded ${uploadedAvatar.objectKey} -> ${publicUrl}`);
+        return { ok: true, publicUrl, objectKey: uploadedAvatar.objectKey };
+    }
+    catch (e) {
+        if (uploaded)
+            await cleanupUploadedAvatar(aid, objectKey, opts?.aunPath);
+        return fail(messageOf(e), 'UPLOAD_FAILED');
+    }
+    finally {
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+    }
+}