evolclaw 2.8.2 → 3.0.0

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 };
+}