evolcore 0.0.1 → 0.0.2

package/dist/aun/outbox.js

@@ -0,0 +1,160 @@
+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,
+        contentKind: opts.contentKind,
+        payload: opts.payload,
+        text: opts.text,
+        filePath: opts.filePath,
+        logText: opts.logText,
+        context: opts.context,
+        ttl: opts.ttl ?? DEFAULT_TTL,
+        postSend: opts.postSend,
+    };
+    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);
+}
+/** Remove durable interaction cards that were cancelled before delivery. */
+export function removeInteractionCards(aid, requestId) {
+    const entries = readEntries(aid);
+    const retained = entries.filter(entry => !(entry.postSend?.type === 'register_interaction_card'
+        && entry.postSend.requestId === requestId));
+    const removed = entries.length - retained.length;
+    if (removed > 0)
+        writeEntries(aid, retained);
+    return removed;
+}
+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 };
+    const drainedIds = new Set(entries.map(e => e.id));
+    let sent = 0;
+    let expired = 0;
+    let failed = 0;
+    const remaining = [];
+    for (const entry of entries) {
+        if (isExpired(entry)) {
+            expired++;
+            continue;
+        }
+        try {
+            entry.attempts = (entry.attempts ?? 0) + 1;
+            const ok = await sender(entry);
+            if (ok) {
+                sent++;
+            }
+            else {
+                failed++;
+                entry.lastError = 'sender returned false';
+                remaining.push(entry);
+            }
+        }
+        catch (e) {
+            failed++;
+            entry.lastError = e instanceof Error ? e.message : String(e);
+            remaining.push(entry);
+        }
+    }
+    const current = readEntries(aid);
+    const currentIds = new Set(current.map(e => e.id));
+    const retainedNewEntries = current.filter(e => !drainedIds.has(e.id));
+    const retainedFailedEntries = remaining.filter(e => currentIds.has(e.id));
+    writeEntries(aid, [...retainedFailedEntries, ...retainedNewEntries]);
+    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,25 @@
+import { getAidStore, loadClient, SLOT } from '../aid/store.js';
+export async function createShortConnection(aid, opts) {
+    const store = await getAidStore({ slotId: opts?.slotId ?? SLOT.cli, aunPath: opts?.aunPath });
+    try {
+        const client = await loadClient(store, aid);
+        await client.connect({ connection_kind: 'short', short_ttl_ms: 30000, auto_reconnect: false });
+        return {
+            async call(method, params) {
+                return client.call(method, params);
+            },
+            async close() {
+                try {
+                    await client.close();
+                }
+                finally {
+                    store.close();
+                }
+            },
+        };
+    }
+    catch (e) {
+        store.close();
+        throw e;
+    }
+}

package/dist/aun/rpc/index.js

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

package/dist/aun/service-proxy.js

@@ -0,0 +1,225 @@
+/**
+ * AUN Service Proxy 集成 — 把本地 HTTP/WS 服务通过控制 AID 暴露到 AUN 网络。
+ *
+ * 访问入口：https://{控制AID}/{serviceName}/...
+ * proxy-server 剥掉 {serviceName} 前缀后，把剩余 path 经隧道转发，
+ * ServiceProxyClient 真实 HTTP/WS 回连本地 endpoint（反向代理）。
+ *
+ * 关键设计：
+ * - providerAid = 控制 AID（daemon 进程身份，pureIdentity 常驻 AUN）
+ * - aunClient 生命周期陷阱：AUNChannel 重连会销毁重建底层 client，
+ *   所以不能把 client 引用直接交给 ServiceProxyClient；传一个动态解引用的
+ *   facade，每次 .call()/.authenticate()/._tokenStore 都读 channel 当前 client。
+ *   serveForever(persistent) 的指数退避会在 client 缺失时自动等待恢复。
+ * - endpoint 发现：source='ecweb' 时读 data/instance/ecweb-*.json 的 port。
+ * - 失败降级：任何异常只 warn，绝不影响 daemon 主流程。
+ */
+import fs from 'fs';
+import path from 'path';
+import { ServiceProxyClient, EndpointPolicy } from '@agentunion/fastaun';
+import { resolvePaths } from '../paths.js';
+import { logger } from '../utils/logger.js';
+const LOG = '[ServiceProxy]';
+const ECWEB_DISCOVERY_TIMEOUT_MS = 10_000;
+const ECWEB_DISCOVERY_INTERVAL_MS = 250;
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * 读 data/instance/ 下存活的 ecweb 实例端口。
+ * 取 startedAt 最新的一条（多实例保护下通常只有一条存活）。
+ */
+function discoverEcwebPort() {
+    const dir = resolvePaths().instanceDir;
+    let files;
+    try {
+        files = fs.readdirSync(dir);
+    }
+    catch {
+        return null;
+    }
+    const records = [];
+    for (const file of files) {
+        if (!/^(ecweb|watch-web)-\d+\.json$/.test(file))
+            continue;
+        try {
+            const rec = JSON.parse(fs.readFileSync(path.join(dir, file), 'utf-8'));
+            if (rec && typeof rec.pid === 'number' && isProcessAlive(rec.pid) && typeof rec.port === 'number') {
+                records.push(rec);
+            }
+        }
+        catch {
+            /* 跳过损坏文件 */
+        }
+    }
+    if (records.length === 0)
+        return null;
+    records.sort((a, b) => (b.startedAt ?? 0) - (a.startedAt ?? 0));
+    return records[0].port;
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        // EPERM = 进程存在但无权限（仍算存活）；ESRCH = 不存在
+        return e?.code === 'EPERM';
+    }
+}
+async function waitForEcwebPort(serviceName) {
+    const deadline = Date.now() + ECWEB_DISCOVERY_TIMEOUT_MS;
+    let loggedWait = false;
+    while (Date.now() <= deadline) {
+        const port = discoverEcwebPort();
+        if (port)
+            return port;
+        if (!loggedWait) {
+            logger.info(`${LOG} 服务 "${serviceName}" source=ecweb，等待 ecweb 实例就绪`);
+            loggedWait = true;
+        }
+        await sleep(ECWEB_DISCOVERY_INTERVAL_MS);
+    }
+    return null;
+}
+/**
+ * 把单个服务配置解析为本地回连 endpoint。无法解析返回 null。
+ */
+async function resolveEndpoint(svc) {
+    if (svc.source === 'ecweb') {
+        const port = await waitForEcwebPort(svc.name);
+        if (!port) {
+            logger.warn(`${LOG} 服务 "${svc.name}" source=ecweb 等待 ${ECWEB_DISCOVERY_TIMEOUT_MS}ms 后仍未发现存活的 ecweb 实例，跳过`);
+            return null;
+        }
+        return `http://127.0.0.1:${port}`;
+    }
+    // static
+    if (svc.endpoint && svc.endpoint.trim())
+        return svc.endpoint.trim();
+    logger.warn(`${LOG} 服务 "${svc.name}" source=static 但未配置 endpoint，跳过`);
+    return null;
+}
+/**
+ * 启动 Service Proxy。挂在控制 AUNChannel 上，常驻反向代理隧道。
+ * 返回 handle 供关停；没有启用服务时返回 null。endpoint 发现和隧道启动在后台执行，
+ * 失败只 warn，不抛异常，不阻塞 daemon 主流程。
+ */
+export function startServiceProxy(controlChannel, providerAid, config) {
+    const services = (config.services ?? []).filter((s) => s.enabled !== false);
+    if (services.length === 0) {
+        logger.info(`${LOG} 无启用的服务，跳过`);
+        return null;
+    }
+    let stopped = false;
+    let proxyClient = null;
+    const run = async () => {
+        try {
+            // 动态解引用 facade：每次访问都读 channel 当前 client，规避重连换 client 的死引用问题。
+            const aunFacade = {
+                call: (method, params) => {
+                    const client = controlChannel.getClient();
+                    if (!client)
+                        return Promise.reject(new Error('AUN control client not connected'));
+                    return client.call(method, params ?? {});
+                },
+                authenticate: () => {
+                    const client = controlChannel.getClient();
+                    if (!client || typeof client.authenticate !== 'function') {
+                        return Promise.reject(new Error('AUN control client not connected'));
+                    }
+                    return client.authenticate();
+                },
+                on: (event, handler) => {
+                    const client = controlChannel.getClient();
+                    return client?.on?.(event, handler);
+                },
+                get _tokenStore() {
+                    return controlChannel.getClient()?._tokenStore;
+                },
+                // ServiceProxyClient._resolveCachedAccessToken 依次读取 _identity / _auth /
+                // _tokenStore + deviceId 来复用 AUNChannel 已签发的 access_token。控制 AID 在
+                // connect 时已 authenticate（client 处于 ready 态），若这些字段不透出，
+                // _ensureAccessToken 会回退到 authenticate() 并抛 "authenticate not allowed
+                // in state ready"，导致隧道永远连不上 proxy-server。动态解引用，规避重连换 client。
+                get _identity() {
+                    return controlChannel.getClient()?._identity;
+                },
+                get _auth() {
+                    return controlChannel.getClient()?._auth;
+                },
+                get _deviceId() {
+                    return controlChannel.getClient()?._deviceId;
+                },
+            };
+            // endpoint 白名单：只允许回连本机回环（127.0.0.1 / localhost 默认放行）。
+            // logger：把 SDK 内部 _logWarn/_logError 接到 evolcore logger，
+            // 否则 serveForever() 的隧道失败被静默吞掉（无任何日志），无法排障。
+            proxyClient = new ServiceProxyClient({
+                providerAid,
+                aunClient: aunFacade,
+                endpointPolicy: new EndpointPolicy(),
+                logger: {
+                    error: (msg, err) => logger.error(`${LOG} ${msg}${err ? ` ${err.stack || err.message}` : ''}`),
+                    warn: (msg) => logger.warn(`${LOG} ${msg}`),
+                    info: (msg) => logger.info(`${LOG} ${msg}`),
+                    debug: (msg) => logger.debug(`${LOG} ${msg}`),
+                },
+            });
+            let registered = 0;
+            for (const svc of services) {
+                if (stopped)
+                    return;
+                const endpoint = await resolveEndpoint(svc);
+                if (stopped)
+                    return;
+                if (!endpoint)
+                    continue;
+                try {
+                    proxyClient.registerService(svc.name, endpoint, {
+                        serviceType: svc.serviceType ?? 'http',
+                        visibility: svc.visibility ?? 'private',
+                        metadata: svc.metadata ?? {},
+                    });
+                    registered += 1;
+                    logger.info(`${LOG} 注册服务 "${svc.name}" → ${endpoint} (visibility=${svc.visibility ?? 'private'})`);
+                }
+                catch (e) {
+                    logger.warn(`${LOG} 注册服务 "${svc.name}" 失败: ${e?.message || e}`);
+                }
+            }
+            if (registered === 0) {
+                logger.warn(`${LOG} 没有成功注册任何服务，不启动隧道`);
+                return;
+            }
+            if (stopped)
+                return;
+            // 常驻持久隧道（内部自带指数退避重连 + client 缺失时自动等待）。
+            // 不 await：后台运行，不阻塞 daemon 启动。
+            proxyClient
+                .serveForever({ connectionMode: 'persistent' })
+                .then((stats) => {
+                logger.info(`${LOG} serveForever 退出: ${JSON.stringify(stats)}`);
+            })
+                .catch((e) => {
+                logger.error(`${LOG} serveForever 异常退出: ${e?.message || e}`);
+            });
+            logger.info(`${LOG} ✓ 已启动，provider=${providerAid}，注册 ${registered} 个服务`);
+        }
+        catch (e) {
+            logger.warn(`${LOG} 启动失败（不影响 daemon 主流程）: ${e?.message || e}`);
+        }
+    };
+    void run();
+    return {
+        stop: () => {
+            stopped = true;
+            try {
+                proxyClient?.stop();
+            }
+            catch {
+                /* noop */
+            }
+        },
+    };
+}

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_aid: 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,68 @@
+import fs from 'fs';
+import crypto from 'crypto';
+import { rpcCall } from '../rpc/index.js';
+function rpcErrorToString(error) {
+    if (!error)
+        return 'unknown error';
+    if (typeof error === 'string')
+        return error;
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function pickUrl(value) {
+    return typeof value === 'string' && value.trim() ? value : undefined;
+}
+export async function storageUpload(aid, localFile, remotePath, opts) {
+    const fileBuffer = fs.readFileSync(localFile);
+    const contentType = opts?.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,
+        size_bytes: fileBuffer.length,
+    }, { aunPath: opts?.aunPath });
+    if (!createResult.ok) {
+        return { ok: false, objectKey: remotePath, error: rpcErrorToString(createResult.error) };
+    }
+    const uploadUrl = createResult.result.upload_url;
+    if (!uploadUrl) {
+        return { ok: false, objectKey: remotePath, error: 'storage.create_upload_session did not return upload_url' };
+    }
+    const putResp = await fetch(uploadUrl, {
+        method: 'PUT',
+        headers: { 'Content-Type': contentType },
+        body: new Blob([new Uint8Array(fileBuffer)], { type: contentType }),
+        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,
+        content_type: contentType,
+        size_bytes: fileBuffer.length,
+        is_private: !(opts?.isPublic),
+    }, { aunPath: opts?.aunPath });
+    if (!completeResult.ok) {
+        return { ok: false, objectKey: remotePath, error: rpcErrorToString(completeResult.error) };
+    }
+    let publicUrl = pickUrl(completeResult.result?.url);
+    if (opts?.isPublic) {
+        if (!publicUrl) {
+            const ticketResult = await rpcCall(aid, 'storage.create_download_ticket', {
+                object_key: remotePath,
+                expire_in_seconds: 86400 * 30, // 30天
+            }, { aunPath: opts?.aunPath });
+            if (ticketResult.ok) {
+                publicUrl = pickUrl(ticketResult.result?.url) ?? pickUrl(ticketResult.result?.download_url);
+            }
+        }
+        publicUrl ??= `https://${aid}/${remotePath}`;
+    }
+    return { ok: true, objectKey: remotePath, publicUrl };
+}