evolclaw 2.8.2 → 3.0.0

package/dist/aun/msg/group.js

@@ -0,0 +1,291 @@
+import { createShortConnection } from '../rpc/index.js';
+import { uploadFileAndBuildPayload } from './upload.js';
+export async function groupSend(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 '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;
+            }
+        }
+        if (args.mentions && args.mentions.length > 0) {
+            payload.mentions = args.mentions;
+        }
+        const result = await conn.call('group.send', { group_id: args.groupId, payload });
+        return {
+            ok: true,
+            group_id: result?.group_id ?? args.groupId,
+            message: result?.message,
+            event: result?.event,
+        };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function groupPull(args) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const params = { group_id: args.groupId };
+        if (args.afterSeq !== undefined)
+            params.after_message_seq = args.afterSeq;
+        if (args.limit !== undefined)
+            params.limit = args.limit;
+        const result = await conn.call('group.pull', params);
+        return {
+            ok: true,
+            group_id: result?.group_id ?? args.groupId,
+            messages: result?.messages ?? [],
+            latest_message_seq: result?.latest_message_seq ?? 0,
+            has_more: !!result?.has_more,
+        };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function groupAck(args) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const result = await conn.call('group.ack', { group_id: args.groupId, seq: args.seq });
+        return {
+            ok: true,
+            group_id: result?.group_id ?? args.groupId,
+            ack_seq: result?.ack_seq ?? args.seq,
+            latest_message_seq: result?.latest_message_seq,
+        };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function groupCreate(args) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const params = { name: args.name };
+        if (args.groupId)
+            params.group_id = args.groupId;
+        if (args.visibility)
+            params.visibility = args.visibility;
+        if (args.description)
+            params.description = args.description;
+        if (args.joinMode)
+            params.join_mode = args.joinMode;
+        const result = await conn.call('group.create', params);
+        return { ok: true, group: result?.group };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function groupInfo(args) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const result = await conn.call('group.get', { group_id: args.groupId });
+        return { ok: true, group: result?.group };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function groupList(args) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const params = {};
+        if (args.size !== undefined)
+            params.size = args.size;
+        const result = await conn.call('group.list_my', params);
+        return {
+            ok: true,
+            items: result?.items ?? [],
+            total: result?.total ?? 0,
+        };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function groupUpdate(args) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const params = { group_id: args.groupId };
+        if (args.name !== undefined)
+            params.name = args.name;
+        if (args.description !== undefined)
+            params.description = args.description;
+        const result = await conn.call('group.update', params);
+        return { ok: true, group: result?.group };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function groupDissolve(args) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const result = await conn.call('group.dissolve', { group_id: args.groupId });
+        return {
+            ok: true,
+            group_id: result?.group_id ?? args.groupId,
+            status: result?.status ?? 'dissolved',
+        };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function groupJoin(args) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const params = { group_id: args.groupId };
+        if (args.message)
+            params.message = args.message;
+        if (args.answer)
+            params.answer = args.answer;
+        const result = await conn.call('group.request_join', params);
+        return { ok: true, group_id: args.groupId, data: result };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function groupLeave(args) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const result = await conn.call('group.leave', { group_id: args.groupId });
+        return { ok: true, group_id: args.groupId, data: result };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function groupInvite(args) {
+    if (args.members.length === 0) {
+        return { ok: false, error: '至少需要一个成员 AID' };
+    }
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    const added = [];
+    const failed = [];
+    try {
+        for (const memberAid of args.members) {
+            try {
+                await conn.call('group.add_member', { group_id: args.groupId, aid: memberAid });
+                added.push(memberAid);
+            }
+            catch (e) {
+                failed.push({ aid: memberAid, error: String(e?.message ?? e) });
+            }
+        }
+        return { ok: true, group_id: args.groupId, added, failed };
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function groupKick(args) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const result = await conn.call('group.kick', { group_id: args.groupId, aid: args.memberAid });
+        return { ok: true, group_id: args.groupId, data: result };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function groupMembers(args) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const params = { group_id: args.groupId };
+        if (args.page !== undefined)
+            params.page = args.page;
+        if (args.size !== undefined)
+            params.size = args.size;
+        const result = await conn.call('group.get_members', params);
+        return {
+            ok: true,
+            members: result?.members ?? [],
+            total: result?.total ?? 0,
+            page: result?.page ?? 1,
+            size: result?.size ?? 50,
+        };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function groupOnline(args) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const result = await conn.call('group.get_online_members', { group_id: args.groupId });
+        return {
+            ok: true,
+            group_id: result?.group_id ?? args.groupId,
+            members: result?.members ?? [],
+            online_count: result?.online_count ?? 0,
+            total: result?.total ?? 0,
+        };
+    }
+    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/index.js

@@ -0,0 +1,4 @@
+export { msgSend, msgPull, msgAck, msgRecall, msgOnline, } from './p2p.js';
+export { groupSend, groupPull, groupAck, groupCreate, groupInfo, groupList, groupUpdate, groupDissolve, groupJoin, groupLeave, groupInvite, groupKick, groupMembers, groupOnline, } from './group.js';
+export { uploadFileAndBuildPayload } from './upload.js';
+export { inferPayloadType, isValidPayloadType } from './payload-type.js';

package/dist/aun/msg/p2p.js

@@ -0,0 +1,144 @@
+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 result = await conn.call('message.send', { to: args.to, payload });
+        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;
+    }
+}