evolclaw 2.8.3 → 3.1.0

package/dist/aun/aid/client.js

@@ -0,0 +1,134 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { execFileSync } from 'child_process';
+import { isWindows } from '../../utils/cross-platform.js';
+/**
+ * Suppress SDK console logs (DEBUG/INFO/WARN) in CLI context.
+ * Call once at CLI entry point — NOT at module load time, to avoid
+ * affecting the daemon process which imports this module for slash commands.
+ */
+export function suppressSdkLogs() {
+    process.env.AUN_LOG_INI_DISABLE = '1';
+    const _origLog = console.log;
+    const _origInfo = console.info;
+    const _origWarn = console.warn;
+    const _origError = console.error;
+    const SDK_LOG_RE = /^\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+\]\[(?:DEBUG|INFO|WARN)\]/;
+    const SDK_ERROR_RE = /^\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+\]\[ERROR\]/;
+    console.log = (...args) => { if (typeof args[0] === 'string') {
+        if (SDK_LOG_RE.test(args[0]))
+            return;
+        if (SDK_ERROR_RE.test(args[0])) {
+            _origError(...args);
+            return;
+        }
+    } _origLog(...args); };
+    console.info = (...args) => { if (typeof args[0] === 'string' && SDK_LOG_RE.test(args[0]))
+        return; _origInfo(...args); };
+    console.warn = (...args) => { if (typeof args[0] === 'string' && SDK_LOG_RE.test(args[0]))
+        return; _origWarn(...args); };
+}
+// ==================== Constants ====================
+export const MIN_AUN_CORE_SDK = [0, 2, 17];
+export const AUN_CORE_SDK_PKG = '@agentunion/fastaun';
+// ==================== SDK & Environment ====================
+function compareVersion(a, min) {
+    const parts = a.split('.').map(n => parseInt(n, 10));
+    if (parts.length < 3 || parts.some(isNaN))
+        return false;
+    if (parts[0] !== min[0])
+        return parts[0] > min[0];
+    if (parts[1] !== min[1])
+        return parts[1] > min[1];
+    return parts[2] >= min[2];
+}
+export function isAunSdkVersionOk(version) {
+    return compareVersion(version, MIN_AUN_CORE_SDK);
+}
+export function resolveAunCoreSdkPkg() {
+    try {
+        let dir = path.dirname(fileURLToPath(import.meta.url));
+        while (true) {
+            const candidate = path.join(dir, 'node_modules', AUN_CORE_SDK_PKG, 'package.json');
+            if (fs.existsSync(candidate)) {
+                const data = JSON.parse(fs.readFileSync(candidate, 'utf-8'));
+                if (data.name === AUN_CORE_SDK_PKG)
+                    return { version: data.version, path: candidate };
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch { /* fall through */ }
+    try {
+        const npmCmd = isWindows ? 'npm.cmd' : 'npm';
+        const globalRoot = execFileSync(npmCmd, ['root', '-g'], {
+            encoding: 'utf-8', timeout: 10000, shell: isWindows,
+        }).trim();
+        const pkgPath = path.join(globalRoot, AUN_CORE_SDK_PKG, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            const data = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            return { version: data.version, path: pkgPath };
+        }
+    }
+    catch { /* not found */ }
+    return null;
+}
+export async function ensureAunSdk() {
+    const installed = resolveAunCoreSdkPkg();
+    if (installed && isAunSdkVersionOk(installed.version))
+        return;
+    const { npmInstallGlobal } = await import('../../utils/npm-ops.js');
+    console.log(`正在安装 ${AUN_CORE_SDK_PKG}@latest...`);
+    await npmInstallGlobal(`${AUN_CORE_SDK_PKG}@latest`);
+}
+export function isAunSdkReady() {
+    const installed = resolveAunCoreSdkPkg();
+    return !!(installed && isAunSdkVersionOk(installed.version));
+}
+// ==================== CA Root ====================
+export async function downloadCaRoot(aunPath, gatewayUrl, indent = '') {
+    const caDir = path.join(aunPath, 'CA', 'root');
+    const caCertPath = path.join(caDir, 'root.crt');
+    if (fs.existsSync(caCertPath))
+        return true;
+    if (!gatewayUrl)
+        return false;
+    try {
+        fs.mkdirSync(caDir, { recursive: true });
+        const gwHttp = gatewayUrl.replace(/^wss?:/, 'https:').replace(/\/aun$/, '');
+        const resp = await fetch(`${gwHttp}/pki/chain`, { redirect: 'follow' });
+        if (!resp.ok) {
+            console.warn(`${indent}⚠ CA 根证书下载失败: HTTP ${resp.status}`);
+            return false;
+        }
+        const body = await resp.text();
+        if (!body.includes('BEGIN CERTIFICATE')) {
+            console.warn(`${indent}⚠ CA 根证书响应内容无效，跳过写入`);
+            return false;
+        }
+        fs.writeFileSync(caCertPath, body);
+        console.log(`${indent}✓ CA 根证书已下载`);
+        return true;
+    }
+    catch (e) {
+        console.warn(`${indent}⚠ CA 根证书下载失败: ${e}，可稍后手动下载`);
+        return false;
+    }
+}
+// ==================== AUNClient Factory ====================
+export async function getAunClient(aid, opts) {
+    const aunPath = opts?.aunPath ?? path.join(os.homedir(), '.aun');
+    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 });
+    return client;
+}

package/dist/aun/aid/identity.js

@@ -0,0 +1,159 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+import { getAunClient, downloadCaRoot } from './client.js';
+import { resolvePaths } from '../../paths.js';
+// ==================== Validation ====================
+export function isValidAid(name) {
+    const labels = name.split('.');
+    return labels.length >= 3 && labels.every(l => /^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(l));
+}
+// ==================== AID Operations ====================
+export function aidList(aunPath) {
+    const aidsDir = path.join(aunPath ?? path.join(os.homedir(), '.aun'), 'AIDs');
+    if (!fs.existsSync(aidsDir))
+        return [];
+    const entries = fs.readdirSync(aidsDir, { withFileTypes: true });
+    return entries
+        .filter(e => e.isDirectory())
+        .map(e => ({
+        aid: e.name,
+        hasPrivateKey: fs.existsSync(path.join(aidsDir, e.name, 'private')),
+        hasAgentMd: fs.existsSync(path.join(aidsDir, e.name, 'agent.md')),
+    }));
+}
+export async function aidCreate(aid, opts) {
+    const aunPath = opts?.aunPath ?? path.join(os.homedir(), '.aun');
+    const aidDir = path.join(aunPath, 'AIDs', aid);
+    if (fs.existsSync(aidDir) && fs.existsSync(path.join(aidDir, 'private'))) {
+        const client = await getAunClient(aid, { aunPath });
+        return { aid, alreadyExisted: true, gateway: '', client };
+    }
+    const { AUNClient, GatewayDiscovery } = await import('@agentunion/fastaun');
+    let client = new AUNClient({ aun_path: aunPath });
+    try {
+        const result = await client.auth.createAid({ aid });
+        const gateway = result.gateway || '';
+        const caDownloaded = await downloadCaRoot(aunPath, gateway);
+        const caCertPath = path.join(aunPath, 'CA', 'root', 'root.crt');
+        if (caDownloaded && fs.existsSync(caCertPath)) {
+            try {
+                await client.close();
+            }
+            catch { /* ignore */ }
+            client = new AUNClient({ aun_path: aunPath, root_ca_path: caCertPath });
+            await client.auth.createAid({ aid });
+        }
+        let gatewayUrl = gateway;
+        if (!gatewayUrl) {
+            try {
+                const discovery = new GatewayDiscovery({});
+                gatewayUrl = await discovery.discover(`https://${aid}/.well-known/aun-gateway`);
+            }
+            catch { /* fall through */ }
+        }
+        if (gatewayUrl) {
+            client._gatewayUrl = gatewayUrl;
+        }
+        return { aid, alreadyExisted: false, gateway: gatewayUrl, client };
+    }
+    catch (e) {
+        try {
+            await client.close();
+        }
+        catch { /* ignore */ }
+        throw e;
+    }
+}
+// ==================== Show ====================
+export function aidShow(aid, opts) {
+    const aunPath = opts?.aunPath ?? path.join(os.homedir(), '.aun');
+    const aidDir = path.join(aunPath, 'AIDs', aid);
+    const hasPrivateKey = fs.existsSync(path.join(aidDir, 'private'));
+    const hasAgentMd = fs.existsSync(path.join(aidDir, 'agent.md'));
+    let certExpiresAt = null;
+    let certSubject = null;
+    const certPath = path.join(aidDir, 'public', 'cert.pem');
+    if (fs.existsSync(certPath)) {
+        try {
+            const pem = fs.readFileSync(certPath, 'utf-8');
+            const x509 = new crypto.X509Certificate(pem);
+            certExpiresAt = x509.validTo;
+            certSubject = x509.subject;
+        }
+        catch { /* ignore parse errors */ }
+    }
+    return { aid, hasPrivateKey, hasAgentMd, certExpiresAt, certSubject };
+}
+// ==================== Delete ====================
+export function aidDelete(aid, opts) {
+    const aunPath = opts?.aunPath ?? path.join(os.homedir(), '.aun');
+    const aidDir = path.join(aunPath, 'AIDs', aid);
+    if (!fs.existsSync(aidDir))
+        return false;
+    fs.rmSync(aidDir, { recursive: true, force: true });
+    return true;
+}
+// ==================== Lookup ====================
+export async function aidLookup(aid) {
+    let gateway = '';
+    try {
+        const gwResp = await fetch(`https://${aid}/.well-known/aun-gateway`, { redirect: 'follow' });
+        if (gwResp.ok) {
+            const text = await gwResp.text();
+            // Response may be JSON with gateways array or plain URL
+            try {
+                const parsed = JSON.parse(text.trim());
+                if (parsed.gateways?.[0]?.url) {
+                    gateway = parsed.gateways[0].url;
+                }
+                else {
+                    gateway = text.trim();
+                }
+            }
+            catch {
+                gateway = text.trim();
+            }
+        }
+    }
+    catch { /* ignore */ }
+    try {
+        const resp = await fetch(`https://${aid}/agent.md`, { redirect: 'follow' });
+        if (resp.ok) {
+            const content = await resp.text();
+            return { exists: true, aid, gateway, content };
+        }
+        return { exists: false, aid, gateway, error: `agent_md_not_found` };
+    }
+    catch (e) {
+        return { exists: false, aid, gateway, error: String(e.message || e) };
+    }
+}
+function lifecycleLogPath(aid) {
+    const aidName = aid.startsWith('@') ? aid.slice(1) : aid;
+    return path.join(resolvePaths().aidLogsDir, `${aidName}.jsonl`);
+}
+export function appendAidLifecycle(event) {
+    const filePath = lifecycleLogPath(event.aid);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.appendFileSync(filePath, JSON.stringify(event) + '\n');
+}
+export function readAidLifecycle(aid, lastN = 50) {
+    const filePath = lifecycleLogPath(aid);
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.trim().split('\n').filter(Boolean);
+        const events = [];
+        for (const line of lines.slice(-lastN)) {
+            try {
+                events.push(JSON.parse(line));
+            }
+            catch { }
+        }
+        return events;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/aun/aid/index.js

@@ -0,0 +1,3 @@
+export { isValidAid, aidList, aidCreate, aidShow, aidDelete, aidLookup, appendAidLifecycle, readAidLifecycle } from './identity.js';
+export { buildInitialAgentMd, agentmdGet, agentmdPut } from './agentmd.js';
+export { MIN_AUN_CORE_SDK, AUN_CORE_SDK_PKG, isAunSdkVersionOk, resolveAunCoreSdkPkg, ensureAunSdk, isAunSdkReady, downloadCaRoot, getAunClient, suppressSdkLogs, } from './client.js';

package/dist/aun/aid/lifecycle-log.js

@@ -0,0 +1,33 @@
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../../paths.js';
+function ensureDir(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+function logPath(aid) {
+    const aidName = aid.startsWith('@') ? aid.slice(1) : aid;
+    return path.join(resolvePaths().aidLogsDir, `${aidName}.jsonl`);
+}
+export function appendAidLifecycle(event) {
+    const filePath = logPath(event.aid);
+    ensureDir(path.dirname(filePath));
+    fs.appendFileSync(filePath, JSON.stringify(event) + '\n');
+}
+export function readAidLifecycle(aid, lastN = 50) {
+    const filePath = logPath(aid);
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.trim().split('\n').filter(Boolean);
+        const events = [];
+        for (const line of lines.slice(-lastN)) {
+            try {
+                events.push(JSON.parse(line));
+            }
+            catch { }
+        }
+        return events;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/aun/aid/types.js

@@ -0,0 +1 @@
+export {};

package/dist/aun/aid/validation.js

@@ -0,0 +1,21 @@
+import fs from 'fs';
+import path from 'path';
+import { isValidAid } from './identity.js';
+/**
+ * `agents/<dirName>` 是否能被当作合法的 self-agent 目录：
+ *   - 目录名通过 isValidAid（标准多级域名）
+ *   - 目录下存在 config.json
+ *
+ * 不满足返回原因字符串，调用方决定是 warn-and-skip 还是 throw。
+ */
+export function checkAgentDir(agentsDir, dirName) {
+    if (!isValidAid(dirName)) {
+        return `dir name "${dirName}" is not a valid AID`;
+    }
+    const configPath = path.join(agentsDir, dirName, 'config.json');
+    if (!fs.existsSync(configPath)) {
+        return `missing ${path.join(dirName, 'config.json')}`;
+    }
+    return null;
+}
+export { isValidAid };

package/dist/aun/msg/group.js

@@ -0,0 +1,293 @@
+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 sendParams = { group_id: args.groupId, payload };
+        sendParams.encrypt = args.encrypt === true;
+        const result = await conn.call('group.send', sendParams);
+        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';