evolclaw 2.8.3 → 3.1.0

package/dist/aun/msg/p2p.js

@@ -0,0 +1,147 @@
+import { createShortConnection } from '../rpc/index.js';
+import { uploadFileAndBuildPayload } from './upload.js';
+export async function msgSend(args) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        let payload;
+        switch (args.body.mode) {
+            case 'text':
+                payload = { type: 'text', text: args.body.text };
+                break;
+            case 'payload':
+                payload = args.body.payload;
+                break;
+            case 'link':
+                payload = { type: 'link', url: args.body.url };
+                if (args.body.title)
+                    payload.title = args.body.title;
+                if (args.body.description)
+                    payload.description = args.body.description;
+                break;
+            case 'file': {
+                const built = await uploadFileAndBuildPayload(conn, args.from, args.body.filePath, {
+                    as: args.body.as,
+                    contentType: args.body.contentType,
+                    text: args.body.text,
+                    transcript: args.body.transcript,
+                });
+                payload = built.payload;
+                break;
+            }
+        }
+        const sendParams = { to: args.to, payload };
+        // Default: plaintext. Set encrypt: true to enable E2EE.
+        sendParams.encrypt = args.encrypt === true;
+        const result = await conn.call('message.send', sendParams);
+        return {
+            ok: true,
+            message_id: result?.message_id,
+            seq: result?.seq,
+            timestamp: result?.timestamp,
+            status: result?.status,
+            delivery_mode: result?.delivery_mode,
+        };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function msgPull(args) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const params = {};
+        if (args.afterSeq !== undefined)
+            params.after_seq = args.afterSeq;
+        if (args.limit !== undefined)
+            params.limit = args.limit;
+        const result = await conn.call('message.pull', params);
+        return {
+            ok: true,
+            messages: result?.messages ?? [],
+            count: result?.count ?? 0,
+            latest_seq: result?.latest_seq ?? 0,
+            earliest_available_seq: result?.earliest_available_seq ?? null,
+            ephemeral_earliest_available_seq: result?.ephemeral_earliest_available_seq ?? null,
+            ephemeral_dropped_count: result?.ephemeral_dropped_count ?? 0,
+        };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function msgAck(args) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const result = await conn.call('message.ack', { seq: args.seq });
+        return {
+            ok: true,
+            ack_seq: result?.ack_seq ?? args.seq,
+            event_published: result?.event_published,
+        };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function msgRecall(args) {
+    if (args.messageIds.length === 0) {
+        return { ok: false, error: 'message_ids 不能为空' };
+    }
+    if (args.messageIds.length > 100) {
+        return { ok: false, error: 'message_ids 最多 100 个' };
+    }
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const result = await conn.call('message.recall', { message_ids: args.messageIds });
+        return {
+            ok: true,
+            accepted: result?.accepted ?? 0,
+            recalled: result?.recalled ?? 0,
+            errors: result?.errors ?? null,
+        };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function msgOnline(args) {
+    if (args.targets.length === 0) {
+        return { ok: false, error: '查询目标不能为空' };
+    }
+    if (args.targets.length > 100) {
+        return { ok: false, error: '一次最多查询 100 个 AID' };
+    }
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const result = await conn.call('message.query_online', { aids: args.targets });
+        return {
+            ok: true,
+            online: result?.online ?? {},
+        };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+// ==================== Internal ====================
+function formatRpcError(e) {
+    if (e?.code !== undefined && e?.message !== undefined) {
+        return { ok: false, error: String(e.message), code: e.code };
+    }
+    return { ok: false, error: String(e?.message ?? e) };
+}

package/dist/aun/msg/payload-type.js

@@ -0,0 +1,27 @@
+import path from 'path';
+const EXT_TYPE_MAP = {
+    // image
+    '.png': 'image', '.jpg': 'image', '.jpeg': 'image',
+    '.gif': 'image', '.webp': 'image', '.svg': 'image',
+    '.bmp': 'image', '.heic': 'image', '.heif': 'image',
+    // video
+    '.mp4': 'video', '.mov': 'video', '.webm': 'video',
+    '.avi': 'video', '.mkv': 'video', '.m4v': 'video',
+    // voice
+    '.opus': 'voice', '.mp3': 'voice', '.aac': 'voice',
+    '.m4a': 'voice', '.wav': 'voice', '.flac': 'voice', '.ogg': 'voice',
+};
+/**
+ * 按扩展名推断 payload.type。
+ * 未识别的扩展名归类为 'file'。
+ */
+export function inferPayloadType(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    return EXT_TYPE_MAP[ext] ?? 'file';
+}
+/**
+ * 校验显式传入的 --as 值。
+ */
+export function isValidPayloadType(value) {
+    return value === 'image' || value === 'video' || value === 'voice' || value === 'file';
+}

package/dist/aun/msg/upload.js

@@ -0,0 +1,98 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { guessMime, formatSize } from '../../utils/media-cache.js';
+import { inferPayloadType, isValidPayloadType } from './payload-type.js';
+/** 小文件阈值：≤64KB 走 storage.put_object 内联 base64；>64KB 走 create_upload_session + HTTP PUT。 */
+const INLINE_UPLOAD_LIMIT = 64 * 1024;
+/** 单次上传最大大小（与 daemon sendFile 一致）。 */
+const MAX_FILE_SIZE = 10 * 1024 * 1024;
+/**
+ * 上传本地文件并构造发送用的 payload。
+ *
+ * 流程：
+ * 1. 读文件、算 sha256、推断 content_type
+ * 2. 小文件 storage.put_object，大文件 storage.create_upload_session + HTTP PUT + storage.complete_upload
+ * 3. 按 as / 扩展名 确定 payload.type
+ * 4. 构造 payload（含 attachments 引用）
+ *
+ * 不做 outbox 持久化、不做 E2EE 加密兜底——这些是 daemon 的职责。
+ * CLI 短连接场景假定网络稳定，失败抛异常给调用方处理。
+ */
+export async function uploadFileAndBuildPayload(conn, ownerAid, filePath, opts) {
+    const absPath = path.resolve(filePath);
+    if (!fs.existsSync(absPath)) {
+        throw new Error(`文件不存在: ${absPath}`);
+    }
+    const stat = fs.statSync(absPath);
+    if (stat.size === 0) {
+        throw new Error(`文件为空: ${absPath}`);
+    }
+    if (stat.size > MAX_FILE_SIZE) {
+        throw new Error(`文件过大 (${formatSize(stat.size)}, 上 ${formatSize(MAX_FILE_SIZE)}): ${absPath}`);
+    }
+    const filename = path.basename(absPath);
+    const fileData = fs.readFileSync(absPath);
+    const sha256 = crypto.createHash('sha256').update(fileData).digest('hex');
+    const contentType = opts?.contentType ?? guessMime(filename);
+    const objectKey = `shared/${crypto.randomUUID()}/${filename}`;
+    if (stat.size <= INLINE_UPLOAD_LIMIT) {
+        await conn.call('storage.put_object', {
+            object_key: objectKey,
+            content: fileData.toString('base64'),
+            content_type: contentType,
+            is_private: false,
+            overwrite: true,
+        });
+    }
+    else {
+        const session = await conn.call('storage.create_upload_session', {
+            object_key: objectKey,
+            size_bytes: stat.size,
+            content_type: contentType,
+        });
+        const uploadUrl = session?.upload_url;
+        if (!uploadUrl)
+            throw new Error('storage.create_upload_session 未返回 upload_url');
+        const uploadResp = await fetch(uploadUrl, { method: 'PUT', body: fileData });
+        if (!uploadResp.ok)
+            throw new Error(`HTTP 上传失败: ${uploadResp.status}`);
+        await conn.call('storage.complete_upload', {
+            object_key: objectKey,
+            sha256,
+            content_type: contentType,
+            is_private: false,
+            size_bytes: stat.size,
+        });
+    }
+    const attachment = {
+        owner_aid: ownerAid,
+        object_key: objectKey,
+        filename,
+        size_bytes: stat.size,
+        sha256,
+        content_type: contentType,
+    };
+    // 确定渲染类型
+    let type;
+    if (opts?.as) {
+        if (!isValidPayloadType(opts.as)) {
+            throw new Error(`--as 必须是 image|video|voice|file，收到: ${opts.as}`);
+        }
+        type = opts.as;
+    }
+    else {
+        type = inferPayloadType(filename);
+    }
+    const payload = {
+        type,
+        attachments: [attachment],
+    };
+    if (opts?.text)
+        payload.text = opts.text;
+    else if (type === 'file')
+        payload.text = `📎 ${filename} (${formatSize(stat.size)})`;
+    if (type === 'voice' && opts?.transcript)
+        payload.transcript = opts.transcript;
+    return { payload, type, attachment };
+}

package/dist/aun/outbox.js

@@ -0,0 +1,138 @@
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { resolvePaths } from '../paths.js';
+const MAX_ENTRIES_PER_AID = 20;
+const DEFAULT_TTL = 300_000; // 5 minutes
+function outboxDir() {
+    return resolvePaths().outboxDir;
+}
+function outboxFile(aid) {
+    return path.join(outboxDir(), `${aid}.jsonl`);
+}
+function generateId() {
+    const ts = Date.now();
+    const rand = crypto.randomBytes(2).toString('hex');
+    return `out-${ts}-${rand}`;
+}
+function isExpired(entry) {
+    return Date.now() - entry.ts > entry.ttl;
+}
+function readEntries(aid) {
+    const file = outboxFile(aid);
+    if (!fs.existsSync(file))
+        return [];
+    try {
+        const content = fs.readFileSync(file, 'utf-8').trim();
+        if (!content)
+            return [];
+        return content.split('\n').map(line => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        }).filter((e) => e !== null);
+    }
+    catch {
+        return [];
+    }
+}
+function writeEntries(aid, entries) {
+    const file = outboxFile(aid);
+    if (entries.length === 0) {
+        try {
+            fs.unlinkSync(file);
+        }
+        catch { }
+        return;
+    }
+    const dir = outboxDir();
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(file, entries.map(e => JSON.stringify(e)).join('\n') + '\n');
+}
+export function enqueue(aid, opts) {
+    const entry = {
+        id: generateId(),
+        ts: Date.now(),
+        aid,
+        channelId: opts.channelId,
+        type: opts.type,
+        text: opts.text,
+        filePath: opts.filePath,
+        context: opts.context,
+        ttl: opts.ttl ?? DEFAULT_TTL,
+    };
+    const dir = outboxDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const file = outboxFile(aid);
+    // Enforce cap: read existing, drop oldest if over limit
+    let entries = readEntries(aid);
+    if (entries.length >= MAX_ENTRIES_PER_AID) {
+        entries = entries.slice(entries.length - MAX_ENTRIES_PER_AID + 1);
+        writeEntries(aid, [...entries, entry]);
+    }
+    else {
+        fs.appendFileSync(file, JSON.stringify(entry) + '\n');
+    }
+    return entry;
+}
+export function remove(aid, id) {
+    const entries = readEntries(aid).filter(e => e.id !== id);
+    writeEntries(aid, entries);
+}
+export function load(aid) {
+    return readEntries(aid).filter(e => !isExpired(e));
+}
+export function cleanup(aid) {
+    const all = readEntries(aid);
+    const valid = all.filter(e => !isExpired(e));
+    const removed = all.length - valid.length;
+    if (removed > 0)
+        writeEntries(aid, valid);
+    return removed;
+}
+export async function drain(aid, sender) {
+    const entries = readEntries(aid);
+    if (entries.length === 0)
+        return { sent: 0, expired: 0, failed: 0 };
+    let sent = 0;
+    let expired = 0;
+    let failed = 0;
+    const remaining = [];
+    for (const entry of entries) {
+        if (isExpired(entry)) {
+            expired++;
+            continue;
+        }
+        try {
+            const ok = await sender(entry);
+            if (ok) {
+                sent++;
+            }
+            else {
+                failed++;
+                remaining.push(entry);
+            }
+        }
+        catch {
+            failed++;
+            remaining.push(entry);
+        }
+    }
+    writeEntries(aid, remaining);
+    return { sent, expired, failed };
+}
+export function hasPending(aid) {
+    const file = outboxFile(aid);
+    if (!fs.existsSync(file))
+        return false;
+    try {
+        const stat = fs.statSync(file);
+        return stat.size > 0;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/aun/rpc/caller.js

@@ -0,0 +1,42 @@
+import { createShortConnection } from './connection.js';
+export async function rpcCall(aid, method, params, opts) {
+    const conn = await createShortConnection(aid, opts);
+    try {
+        const result = await conn.call(method, params);
+        return { ok: true, result };
+    }
+    catch (e) {
+        if (e.code !== undefined && e.message !== undefined) {
+            return { ok: false, error: { code: e.code, message: e.message, data: e.data } };
+        }
+        return { ok: false, error: { code: -1, message: String(e.message || e) } };
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function rpcBatch(aid, calls, opts) {
+    const conn = await createShortConnection(aid, opts);
+    const results = [];
+    try {
+        for (const { method, params } of calls) {
+            try {
+                const result = await conn.call(method, params);
+                results.push({ ok: true, result });
+            }
+            catch (e) {
+                if (e.code !== undefined && e.message !== undefined) {
+                    results.push({ ok: false, error: { code: e.code, message: e.message, data: e.data } });
+                }
+                else {
+                    results.push({ ok: false, error: { code: -1, message: String(e.message || e) } });
+                }
+                break; // stop on first failure
+            }
+        }
+    }
+    finally {
+        await conn.close();
+    }
+    return results;
+}

package/dist/aun/rpc/connection.js

@@ -0,0 +1,34 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+export async function createShortConnection(aid, opts) {
+    const aunPath = opts?.aunPath ?? path.join(os.homedir(), '.aun');
+    const slotId = opts?.slotId ?? '';
+    const caCertPath = path.join(aunPath, 'CA', 'root', 'root.crt');
+    const { AUNClient } = await import('@agentunion/fastaun');
+    const clientOpts = { aun_path: aunPath, debug: false };
+    if (fs.existsSync(caCertPath))
+        clientOpts.root_ca_path = caCertPath;
+    const client = new AUNClient(clientOpts);
+    await client.auth.createAid({ aid });
+    const authResult = await client.auth.authenticate({ aid });
+    const accessToken = authResult?.access_token ?? client._access_token;
+    const gateway = client._gatewayUrl ?? authResult?.gateway;
+    await client.connect({
+        access_token: accessToken,
+        gateway,
+        slot_id: slotId,
+        connection_kind: 'short',
+    }, { auto_reconnect: false });
+    return {
+        async call(method, params) {
+            return client.call(method, params);
+        },
+        async close() {
+            try {
+                await client.close();
+            }
+            catch { /* ignore */ }
+        },
+    };
+}

package/dist/aun/rpc/index.js

@@ -0,0 +1,2 @@
+export { rpcCall, rpcBatch } from './caller.js';
+export { createShortConnection } from './connection.js';

package/dist/aun/storage/download.js

@@ -0,0 +1,29 @@
+import fs from 'fs';
+import path from 'path';
+import { rpcCall } from '../rpc/index.js';
+export async function storageDownload(aid, url, localPath, opts) {
+    // Parse URL: strip https:// prefix, split into owner + path
+    const cleaned = url.replace(/^https?:\/\//, '');
+    const slashIdx = cleaned.indexOf('/');
+    if (slashIdx === -1) {
+        return { ok: false, localPath: '', size: 0, error: 'URL 格式错误，需要 <owner-aid>/<path>' };
+    }
+    const ownerAid = cleaned.slice(0, slashIdx);
+    const objectKey = cleaned.slice(slashIdx + 1);
+    const ticketResult = await rpcCall(aid, 'storage.create_download_ticket', {
+        owner: ownerAid,
+        object_key: objectKey,
+    }, { aunPath: opts?.aunPath });
+    if (!ticketResult.ok) {
+        return { ok: false, localPath: '', size: 0, error: JSON.stringify(ticketResult.error) };
+    }
+    const downloadUrl = ticketResult.result.download_url;
+    const resp = await fetch(downloadUrl);
+    if (!resp.ok) {
+        return { ok: false, localPath: '', size: 0, error: `HTTP GET failed: ${resp.status}` };
+    }
+    const buffer = Buffer.from(await resp.arrayBuffer());
+    const outPath = localPath ?? path.basename(objectKey);
+    fs.writeFileSync(outPath, buffer);
+    return { ok: true, localPath: outPath, size: buffer.length };
+}

package/dist/aun/storage/index.js

@@ -0,0 +1,3 @@
+export { storageUpload } from './upload.js';
+export { storageDownload } from './download.js';
+export { storageLs, storageRm, storageQuota } from './manage.js';

package/dist/aun/storage/manage.js

@@ -0,0 +1,10 @@
+import { rpcCall } from '../rpc/caller.js';
+export async function storageLs(aid, prefix, opts) {
+    return rpcCall(aid, 'storage.list_objects', { prefix: prefix || '' }, { aunPath: opts?.aunPath });
+}
+export async function storageRm(aid, remotePath, opts) {
+    return rpcCall(aid, 'storage.delete_object', { object_key: remotePath }, { aunPath: opts?.aunPath });
+}
+export async function storageQuota(aid, opts) {
+    return rpcCall(aid, 'storage.get_quota', {}, { aunPath: opts?.aunPath });
+}

package/dist/aun/storage/upload.js

@@ -0,0 +1,35 @@
+import fs from 'fs';
+import crypto from 'crypto';
+import { rpcCall } from '../rpc/index.js';
+export async function storageUpload(aid, localFile, remotePath, opts) {
+    const fileBuffer = fs.readFileSync(localFile);
+    const contentType = 'application/octet-stream';
+    const sha256 = crypto.createHash('sha256').update(fileBuffer).digest('hex');
+    const createResult = await rpcCall(aid, 'storage.create_upload_session', {
+        object_key: remotePath,
+        content_type: contentType,
+        content_length: fileBuffer.length,
+        is_private: !(opts?.isPublic),
+    }, { aunPath: opts?.aunPath });
+    if (!createResult.ok) {
+        return { ok: false, objectKey: remotePath, error: JSON.stringify(createResult.error) };
+    }
+    const uploadUrl = createResult.result.upload_url;
+    const putResp = await fetch(uploadUrl, {
+        method: 'PUT',
+        headers: { 'Content-Type': contentType },
+        body: new Blob([fileBuffer]),
+        redirect: 'follow',
+    });
+    if (!putResp.ok) {
+        return { ok: false, objectKey: remotePath, error: `HTTP PUT failed: ${putResp.status}` };
+    }
+    const completeResult = await rpcCall(aid, 'storage.complete_upload', {
+        object_key: remotePath,
+        sha256,
+    }, { aunPath: opts?.aunPath });
+    if (!completeResult.ok) {
+        return { ok: false, objectKey: remotePath, error: JSON.stringify(completeResult.error) };
+    }
+    return { ok: true, objectKey: remotePath };
+}