evolcore 0.0.12 → 0.0.14

package/dist/aun/msg/managed-operation.js

@@ -5,6 +5,7 @@ import { msgOnline } from './p2p.js';
 import { resolveRoot } from '../../paths.js';
 import { isExplicitGroupId } from '../group-identity.js';
 import { isValidAid } from '../aid/validation.js';
+import { downloadGroupFsBytes } from '../group-fs-download.js';
 import { groupBan, groupBanlist, groupCreate, groupDissolve, groupInfo, groupInvite, groupJoin, groupKick, groupLeave, groupList, groupMembers, groupOnline, groupPull, groupAck, groupResume, groupRules, groupRulesFileGet, groupRulesFilePublish, groupRulesFileSet, groupSetRole, groupSuspend, groupTransferOwner, groupUnban, groupUpdate, groupUpdateRules, } from './group.js';
 /** Rules uploaded by a managed task are carried as bounded UTF-8 content. */
 export const MAX_MANAGED_GROUP_RULES_BYTES = 4 * 1024;
@@ -560,8 +561,9 @@ export class ManagedFsOperationError extends Error {
 }
 const FS_VALUE_FLAGS = new Set([
     '--as', '--format', '--max-bytes', '--head-bytes', '--name', '--pattern', '--type', '--node-type',
-    '--size', '--mtime', '--page', '--page-size',
+    '--size', '--mtime', '--page', '--page-size', '-m', '-x',
 ]);
+const FS_BOOLEAN_FLAGS = new Set(['-p', '--parents', '-r', '--recursive', '-f', '--force', '--overwrite']);
 function failFs(code, reason) {
     return { ok: false, code, reason };
 }
@@ -587,29 +589,37 @@ function parseRemote(value, allowEmpty) {
     }
     if (remotePath === '' && allowEmpty)
         return { groupId, remotePath: '' };
-    if (!remotePath.startsWith('/') || remotePath.length > MAX_REMOTE_PATH_LENGTH || /[\u0000-\u001f\u007f]/.test(remotePath)) {
+    if (!remotePath.startsWith('/') || remotePath.length > MAX_REMOTE_PATH_LENGTH || /[\u0000-\u001f\u007f]/.test(remotePath)
+        || remotePath.split('/').includes('..')) {
         return failFs('INVALID_PATH', 'remote group path must be a bounded absolute path');
     }
     return { groupId, remotePath };
 }
-/** Parse the daemon-owned, current-group read-only filesystem grammar. */
+/** Parse the daemon-owned, current-group filesystem grammar. */
 export function resolveManagedFsOperation(argv) {
     const raw = argv[0] === 'fs' ? argv.slice(1) : argv;
-    const kind = raw[0];
-    if (!kind || !['ls', 'stat', 'lstat', 'cat', 'find', 'df'].includes(kind)) {
-        return failFs('NOT_ALLOWED', `unsupported managed fs command: ${kind || '<missing>'}`);
+    const rawKind = raw[0];
+    if (!rawKind || !['ls', 'stat', 'lstat', 'cat', 'find', 'df', 'getfacl', 'setfacl', 'mkdir', 'cp', 'mv', 'rm'].includes(rawKind)) {
+        return failFs('NOT_ALLOWED', `unsupported managed fs command: ${rawKind || '<missing>'}`);
     }
     const values = new Map();
+    const booleanFlags = new Set();
     const positionals = [];
     let follow = false;
     for (let index = 1; index < raw.length; index++) {
         const token = raw[index];
         if (token === '-L' || token === '--follow') {
-            if (kind !== 'stat')
+            if (rawKind !== 'stat')
                 return failFs('NOT_ALLOWED', `${token} is only allowed for stat`);
             follow = true;
             continue;
         }
+        if (FS_BOOLEAN_FLAGS.has(token)) {
+            if (booleanFlags.has(token))
+                return failFs('INVALID_ARGUMENT', `${token} may only be specified once`);
+            booleanFlags.add(token);
+            continue;
+        }
         if (!token.startsWith('-')) {
             positionals.push(token);
             continue;
@@ -622,12 +632,10 @@ export function resolveManagedFsOperation(argv) {
         if (values.has(token))
             return failFs('INVALID_ARGUMENT', `${token} may only be specified once`);
         const value = raw[++index];
-        if (!value || value.startsWith('--'))
+        if (!value || value.startsWith('-'))
             return failFs('INVALID_ARGUMENT', `${token} requires a value`);
         values.set(token, value);
     }
-    if (positionals.length !== 1)
-        return failFs('INVALID_ARGUMENT', `${kind} accepts exactly one remote group path`);
     const actorAidValue = values.get('--as');
     const actorAid = actorAidValue === undefined ? undefined : actorAidValue.replace(/^@/, '');
     if (actorAid !== undefined && !isValidAid(actorAid))
@@ -635,22 +643,107 @@ export function resolveManagedFsOperation(argv) {
     const format = values.get('--format');
     if (format !== undefined && format !== 'json')
         return failFs('INVALID_ARGUMENT', '--format only supports json');
-    const allowedByKind = {
-        ls: new Set(['--as', '--format']),
-        stat: new Set(['--as', '--format']),
-        lstat: new Set(['--as', '--format']),
+    const expected = rawKind === 'cp' || rawKind === 'mv' ? 2 : 1;
+    if (positionals.length !== expected)
+        return failFs('INVALID_ARGUMENT', `${rawKind} accepts ${expected} positional argument${expected === 1 ? '' : 's'}`);
+    const allowedValues = {
+        ls: new Set(['--as', '--format']), stat: new Set(['--as', '--format']), lstat: new Set(['--as', '--format']),
         cat: new Set(['--as', '--format', '--max-bytes', '--head-bytes']),
         find: new Set(['--as', '--format', '--name', '--pattern', '--type', '--node-type', '--size', '--mtime', '--page', '--page-size']),
-        df: new Set(['--as', '--format']),
+        df: new Set(['--as', '--format']), mkdir: new Set(['--as', '--format']), cp: new Set(['--as', '--format']),
+        mv: new Set(['--as', '--format']), rm: new Set(['--as', '--format']),
+        getfacl: new Set(['--as', '--format']), setfacl: new Set(['--as', '--format', '-m', '-x']),
     };
-    for (const flag of values.keys()) {
-        if (!allowedByKind[kind].has(flag))
-            return failFs('NOT_ALLOWED', `${flag} is not allowed for managed fs ${kind}`);
-    }
-    const remote = parseRemote(positionals[0], kind === 'df');
+    const allowedBoolean = {
+        ls: new Set(), stat: new Set(), lstat: new Set(), cat: new Set(), find: new Set(), df: new Set(), getfacl: new Set(), setfacl: new Set(),
+        mkdir: new Set(['-p', '--parents']), cp: new Set(['-r', '--recursive', '-f', '--force', '--overwrite']),
+        mv: new Set(['-f', '--force', '--overwrite']), rm: new Set(['-r', '--recursive', '-f', '--force', '--overwrite']),
+    };
+    for (const flag of values.keys())
+        if (!allowedValues[rawKind].has(flag))
+            return failFs('NOT_ALLOWED', `${flag} is not allowed for managed fs ${rawKind}`);
+    for (const flag of booleanFlags)
+        if (!allowedBoolean[rawKind].has(flag))
+            return failFs('NOT_ALLOWED', `${flag} is not allowed for managed fs ${rawKind}`);
+    const overwrite = booleanFlags.has('-f') || booleanFlags.has('--force') || booleanFlags.has('--overwrite');
+    const recursive = booleanFlags.has('-r') || booleanFlags.has('--recursive');
+    const remoteOrError = (value, allowEmpty = false) => parseRemote(value, allowEmpty);
+    if (rawKind === 'getfacl') {
+        if (values.has('-m') || values.has('-x'))
+            return failFs('NOT_ALLOWED', 'getfacl does not accept ACL mutation flags');
+        const remote = remoteOrError(positionals[0]);
+        if (!('groupId' in remote))
+            return remote;
+        return { ok: true, command: {
+                kind: 'getfacl', operationId: 'ec.fs.getfacl', canonicalArgv: ['fs', 'getfacl', positionals[0], ...(actorAid ? ['--as', actorAid] : [])],
+                actorAid, groupId: remote.groupId, remotePath: remote.remotePath,
+            } };
+    }
+    if (rawKind === 'setfacl') {
+        const modify = values.get('-m');
+        const remove = values.get('-x');
+        if (!!modify === !!remove)
+            return failFs('INVALID_ARGUMENT', 'setfacl requires exactly one of -m or -x');
+        const spec = modify ?? remove ?? '';
+        const parsedAcl = parseManagedGroupAclSpec(spec, modify !== undefined);
+        if (!('grantee' in parsedAcl))
+            return parsedAcl;
+        const remote = remoteOrError(positionals[0]);
+        if (!('groupId' in remote))
+            return remote;
+        return { ok: true, command: {
+                kind: 'setfacl', operationId: 'ec.fs.setfacl', canonicalArgv: ['fs', 'setfacl', positionals[0], modify !== undefined ? '-m' : '-x', spec, ...(actorAid ? ['--as', actorAid] : [])],
+                actorAid, groupId: remote.groupId, remotePath: remote.remotePath,
+                aclGrantee: parsedAcl.grantee, ...(parsedAcl.perms ? { aclPerms: parsedAcl.perms } : {}), aclRemove: remove !== undefined,
+            } };
+    }
+    if (rawKind === 'cp') {
+        const destination = remoteOrError(positionals[1]);
+        if (!('groupId' in destination))
+            return destination;
+        const source = positionals[0].includes(':') ? remoteOrError(positionals[0]) : undefined;
+        if (source && !('groupId' in source))
+            return source;
+        if (source && source.groupId !== destination.groupId)
+            return failFs('INVALID_GROUP', 'managed cp cannot cross groups');
+        const kind = source ? 'copy' : 'upload';
+        return { ok: true, command: {
+                kind, operationId: `ec.fs.${kind}`, canonicalArgv: ['fs', 'cp', positionals[0], positionals[1], ...(actorAid ? ['--as', actorAid] : [])],
+                actorAid, groupId: destination.groupId, remotePath: destination.remotePath, destinationPath: destination.remotePath,
+                ...(source ? { remoteSourcePath: source.remotePath } : { localPath: positionals[0] }), overwrite, recursive,
+            } };
+    }
+    if (rawKind === 'mv') {
+        const source = remoteOrError(positionals[0]);
+        const destination = remoteOrError(positionals[1]);
+        if (!('groupId' in source))
+            return source;
+        if (!('groupId' in destination))
+            return destination;
+        if (source.groupId !== destination.groupId)
+            return failFs('INVALID_GROUP', 'managed mv cannot cross groups');
+        return { ok: true, command: {
+                kind: 'move', operationId: 'ec.fs.move', canonicalArgv: ['fs', 'mv', positionals[0], positionals[1], ...(actorAid ? ['--as', actorAid] : [])],
+                actorAid, groupId: destination.groupId, remotePath: destination.remotePath, destinationPath: destination.remotePath,
+                remoteSourcePath: source.remotePath, overwrite,
+            } };
+    }
+    const remote = remoteOrError(positionals[0], rawKind === 'df');
     if (!('groupId' in remote))
         return remote;
-    const effectiveKind = kind === 'stat' && !follow ? 'lstat' : kind;
+    if (rawKind === 'mkdir')
+        return { ok: true, command: {
+                kind: 'mkdir', operationId: 'ec.fs.mkdir', canonicalArgv: ['fs', 'mkdir', positionals[0], ...(actorAid ? ['--as', actorAid] : [])],
+                actorAid, groupId: remote.groupId, remotePath: remote.remotePath, parents: booleanFlags.has('-p') || booleanFlags.has('--parents'),
+            } };
+    if (rawKind === 'rm' && remote.remotePath === '/')
+        return failFs('INVALID_PATH', 'managed rm cannot target the group root');
+    if (rawKind === 'rm')
+        return { ok: true, command: {
+                kind: 'remove', operationId: 'ec.fs.remove', canonicalArgv: ['fs', 'rm', positionals[0], ...(actorAid ? ['--as', actorAid] : [])],
+                actorAid, groupId: remote.groupId, remotePath: remote.remotePath, recursive, overwrite,
+            } };
+    const effectiveKind = rawKind === 'stat' && !follow ? 'lstat' : rawKind;
     const maxBytes = positiveInteger(values.get('--max-bytes'), '--max-bytes', MAX_MANAGED_FS_CAT_BYTES);
     if (typeof maxBytes !== 'number' && maxBytes !== undefined)
         return maxBytes;
@@ -664,28 +757,33 @@ export function resolveManagedFsOperation(argv) {
     if (typeof pageSize !== 'number' && pageSize !== undefined)
         return pageSize;
     const nodeType = values.get('--type') ?? values.get('--node-type');
-    if (nodeType !== undefined && !['f', 'd', 'l'].includes(nodeType)) {
+    if (nodeType !== undefined && !['f', 'd', 'l'].includes(nodeType))
         return failFs('INVALID_ARGUMENT', '--type only supports f|d|l');
+    return { ok: true, command: {
+            kind: effectiveKind, operationId: `ec.fs.${effectiveKind}`, canonicalArgv: ['fs', effectiveKind, positionals[0], ...(actorAid ? ['--as', actorAid] : [])],
+            actorAid, groupId: remote.groupId, remotePath: remote.remotePath, maxBytes, headBytes,
+            name: values.get('--name') ?? values.get('--pattern'), nodeType, size: values.get('--size'), mtime: values.get('--mtime'), page, pageSize,
+        } };
+}
+function parseManagedGroupAclSpec(value, requirePerms) {
+    const parts = value.split(':');
+    if (parts[0] !== 'role' || !parts[1] || parts.length !== (requirePerms ? 3 : 2)) {
+        return failFs('INVALID_ARGUMENT', 'group ACL entry must use role:member:<perms>, role:admin:<perms>, or role:<role>');
     }
-    return {
-        ok: true,
-        command: {
-            kind: effectiveKind,
-            operationId: `ec.fs.${effectiveKind}`,
-            canonicalArgv: ['fs', effectiveKind, `${remote.groupId}:${remote.remotePath}`, ...(actorAid ? ['--as', actorAid] : [])],
-            actorAid,
-            groupId: remote.groupId,
-            remotePath: remote.remotePath,
-            maxBytes,
-            headBytes,
-            name: values.get('--name') ?? values.get('--pattern'),
-            nodeType,
-            size: values.get('--size'),
-            mtime: values.get('--mtime'),
-            page,
-            pageSize,
-        },
-    };
+    const grantee = `role:${parts[1]}`;
+    if (grantee !== 'role:member' && grantee !== 'role:admin') {
+        return failFs('INVALID_ARGUMENT', 'group ACL only supports role:member or role:admin');
+    }
+    if (!requirePerms)
+        return { grantee };
+    const perms = parts[2];
+    if (!perms || !/^(?:r|rw|rwx)$/.test(perms)) {
+        return failFs('INVALID_ARGUMENT', 'group ACL permissions must be r, rw, or rwx');
+    }
+    if (grantee === 'role:member' && perms !== 'rw') {
+        return failFs('INVALID_ARGUMENT', 'role:member may only receive rw group ACL permissions');
+    }
+    return { grantee, perms };
 }
 function numberFrom(value, keys) {
     for (const key of keys) {
@@ -695,18 +793,6 @@ function numberFrom(value, keys) {
     }
     return undefined;
 }
-function bytesFromDownload(value) {
-    const candidate = value?.bytes ?? value?.data ?? value?.content ?? value?.blob ?? value;
-    if (candidate instanceof Uint8Array)
-        return candidate;
-    if (Buffer.isBuffer(candidate))
-        return new Uint8Array(candidate);
-    if (typeof candidate === 'string')
-        return new Uint8Array(Buffer.from(candidate, 'base64'));
-    if (Array.isArray(candidate))
-        return new Uint8Array(candidate);
-    throw new ManagedFsOperationError('FS_DOWNLOAD_INVALID', 'group filesystem returned an unsupported blob');
-}
 async function withClient(actorAid, fn) {
     const store = await getAidStore({ slotId: SLOT.cli, aunPath: resolveRoot() });
     let client;
@@ -728,7 +814,7 @@ async function withClient(actorAid, fn) {
         catch { /* best effort */ }
     }
 }
-/** Execute a parsed read against the current group using daemon-owned credentials. */
+/** Execute a parsed operation against the current group using daemon-owned credentials. */
 export async function executeManagedFsOperation(command) {
     if (!command.actorAid)
         throw new ManagedFsOperationError('INVALID_ACTOR', 'managed fs actor is required');
@@ -736,6 +822,31 @@ export async function executeManagedFsOperation(command) {
     try {
         return await withClient(command.actorAid, async (client) => {
             switch (command.kind) {
+                case 'mkdir':
+                    return { ok: true, command: 'mkdir', path: ref, result: await client.group.fs.mkdir(ref, { parents: command.parents }) };
+                case 'upload': {
+                    if (!command.localPath)
+                        throw new ManagedFsOperationError('INVALID_SOURCE', 'managed upload source is required');
+                    return { ok: true, command: 'upload', path: ref, localPath: command.localPath,
+                        result: await client.group.fs.cp(command.localPath, ref, { parents: true, overwrite: command.overwrite, force: command.overwrite }) };
+                }
+                case 'copy': {
+                    if (!command.remoteSourcePath)
+                        throw new ManagedFsOperationError('INVALID_SOURCE', 'managed copy source is required');
+                    const source = `${command.groupId}:${command.remoteSourcePath}`;
+                    return { ok: true, command: 'copy', src: source, path: ref,
+                        result: await client.group.fs.cp(source, ref, { recursive: command.recursive, overwrite: command.overwrite, force: command.overwrite }) };
+                }
+                case 'move': {
+                    if (!command.remoteSourcePath)
+                        throw new ManagedFsOperationError('INVALID_SOURCE', 'managed move source is required');
+                    const source = `${command.groupId}:${command.remoteSourcePath}`;
+                    return { ok: true, command: 'move', src: source, path: ref,
+                        result: await client.group.fs.mv(source, ref, { overwrite: command.overwrite, force: command.overwrite }) };
+                }
+                case 'remove':
+                    return { ok: true, command: 'remove', path: ref,
+                        result: await client.group.fs.rm(ref, { recursive: command.recursive, force: command.overwrite }) };
                 case 'ls': {
                     const raw = await client.group.fs.ls(ref);
                     const value = raw;
@@ -762,6 +873,16 @@ export async function executeManagedFsOperation(command) {
                 }
                 case 'df':
                     return { ok: true, command: 'df', path: `${command.groupId}:`, usage: await client.group.fs.df(`${command.groupId}:`) };
+                case 'getfacl':
+                    return { ok: true, command: 'getfacl', path: ref, result: await client.group.fs.getAcl(ref) };
+                case 'setfacl': {
+                    if (!command.aclGrantee)
+                        throw new ManagedFsOperationError('INVALID_ACL', 'group ACL grantee is required');
+                    const result = command.aclRemove
+                        ? await client.group.fs.removeAcl(ref, { granteeAid: command.aclGrantee })
+                        : await client.group.fs.setAcl(ref, { granteeAid: command.aclGrantee, perms: command.aclPerms });
+                    return { ok: true, command: 'setfacl', path: ref, grantee: command.aclGrantee, removed: !!command.aclRemove, result };
+                }
                 case 'cat': {
                     const node = await client.group.fs.stat(ref);
                     const size = numberFrom(node, ['size', 'size_bytes', 'bytes']);
@@ -770,7 +891,7 @@ export async function executeManagedFsOperation(command) {
                         throw new ManagedFsOperationError('FS_SIZE_REQUIRED', 'group file size is required before managed cat');
                     if (size > maxBytes)
                         throw new ManagedFsOperationError('FS_CAT_TOO_LARGE', `managed cat is limited to ${maxBytes} bytes`);
-                    const bytes = bytesFromDownload(await client.group.fs.cp(ref, { kind: 'blob' }, { verifyHash: true }));
+                    const { bytes } = await downloadGroupFsBytes(client, ref);
                     if (bytes.byteLength > maxBytes)
                         throw new ManagedFsOperationError('FS_CAT_TOO_LARGE', `managed cat is limited to ${maxBytes} bytes`);
                     const headBytes = Math.min(command.headBytes ?? 256, MAX_MANAGED_FS_HEAD_BYTES, bytes.byteLength);

package/dist/aun/msg/upload.js

@@ -2,7 +2,22 @@ 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';
+const EXT_TYPE_MAP = {
+    '.png': 'image', '.jpg': 'image', '.jpeg': 'image',
+    '.gif': 'image', '.webp': 'image', '.svg': 'image',
+    '.bmp': 'image', '.heic': 'image', '.heif': 'image',
+    '.mp4': 'video', '.mov': 'video', '.webm': 'video',
+    '.avi': 'video', '.mkv': 'video', '.m4v': 'video',
+    '.opus': 'voice', '.mp3': 'voice', '.aac': 'voice',
+    '.m4a': 'voice', '.wav': 'voice', '.flac': 'voice', '.ogg': 'voice',
+};
+export function inferPayloadType(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    return EXT_TYPE_MAP[ext] ?? 'file';
+}
+export function isValidPayloadType(value) {
+    return value === 'image' || value === 'video' || value === 'voice' || value === 'file';
+}
 /** 单次上传最大大小（与 daemon sendFile 一致）。 */
 export const MAX_AUN_ATTACHMENT_SIZE = 10 * 1024 * 1024;
 /** server 端 inline 上限错误的识别特征。优先匹配错误消息里的“inline 上限”字样。 */

package/dist/aun/outbox.js

@@ -1,6 +1,7 @@
 import crypto from 'crypto';
 import { agentOutboxPath } from '../paths.js';
 import { atomicRead, atomicWrite } from '../utils/atomic-write.js';
+import { isDeliveryTarget, isDeliveryTargetForChannel, sameDeliveryTarget } from '../core/message/message-utils.js';
 const MAX_ENTRIES_PER_AID = 20;
 const DEFAULT_TTL = 300_000; // 5 minutes
 function outboxFile(aid) {
@@ -16,6 +17,9 @@ function isExpired(entry) {
         return false;
     return Date.now() - entry.ts > entry.ttl;
 }
+export function isDeliveryForChannel(value, channelId) {
+    return isDeliveryTargetForChannel(value, channelId);
+}
 function readEntries(aid) {
     const file = outboxFile(aid);
     try {
@@ -43,17 +47,32 @@ function writeEntries(aid, entries) {
     atomicWrite(file, content);
 }
 export function enqueue(aid, opts) {
-    const existingEntries = readEntries(aid);
+    const delivery = opts.delivery;
+    if (!isDeliveryForChannel(delivery, opts.channelId)) {
+        const code = isDeliveryTarget(delivery) ? 'AUN_OUTBOUND_ROUTE_MISMATCH' : 'AUN_OUTBOUND_ROUTE_REQUIRED';
+        throw Object.assign(new Error(`invalid AUN outbox delivery route for channelId=${opts.channelId}`), { code });
+    }
+    let existingEntries = readEntries(aid);
     if (opts.dedupeKey) {
         const existing = existingEntries.find(entry => entry.dedupeKey === opts.dedupeKey && !isExpired(entry));
-        if (existing)
+        if (existing
+            && existing.channelId === opts.channelId
+            && isDeliveryForChannel(existing.delivery, existing.channelId)
+            && sameDeliveryTarget(existing.delivery, delivery)) {
             return existing;
+        }
+        if (existing) {
+            // A pre-route entry must not block corrected code from persisting the
+            // same logical operation with an explicit delivery target.
+            existingEntries = existingEntries.filter(entry => entry.id !== existing.id);
+        }
     }
     const entry = {
         id: generateId(),
         ts: Date.now(),
         aid,
         channelId: opts.channelId,
+        delivery,
         dedupeKey: opts.dedupeKey,
         critical: opts.critical,
         type: opts.type,
@@ -123,6 +142,9 @@ export function cleanup(aid) {
 // duplicate sends while allowing a later drain trigger to pick up entries
 // enqueued during an active pass.
 const activeDrainTails = new Map();
+function hasRouteForChannel(entry) {
+    return isDeliveryForChannel(entry.delivery, entry.channelId);
+}
 async function drainOnce(aid, sender) {
     const entries = readEntries(aid);
     if (entries.length === 0)
@@ -137,6 +159,13 @@ async function drainOnce(aid, sender) {
             expired++;
             continue;
         }
+        if (!hasRouteForChannel(entry)) {
+            // A route is security-sensitive metadata. An entry whose groupId does
+            // not match its address cannot be repaired from channelId, so remove it
+            // instead of retrying the same malformed send forever.
+            expired++;
+            continue;
+        }
         try {
             entry.attempts = (entry.attempts ?? 0) + 1;
             const ok = await sender(entry);

package/dist/aun/rpc/client.js

@@ -0,0 +1,66 @@
+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 (error) {
+        store.close();
+        throw error;
+    }
+}
+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 (error) {
+        if (error.code !== undefined && error.message !== undefined) {
+            return { ok: false, error: { code: error.code, message: error.message, data: error.data } };
+        }
+        return { ok: false, error: { code: -1, message: String(error.message || error) } };
+    }
+    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 (error) {
+                if (error.code !== undefined && error.message !== undefined) {
+                    results.push({ ok: false, error: { code: error.code, message: error.message, data: error.data } });
+                }
+                else {
+                    results.push({ ok: false, error: { code: -1, message: String(error.message || error) } });
+                }
+                break;
+            }
+        }
+    }
+    finally {
+        await conn.close();
+    }
+    return results;
+}

package/dist/aun/rpc/index.js

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

package/dist/aun/storage/{upload.js → client.js}

@@ -46,7 +46,7 @@ export async function storageUpload(aid, localFile, remotePath, opts) {
         sha256,
         content_type: contentType,
         size_bytes: fileBuffer.length,
-        is_private: !(opts?.isPublic),
+        is_private: !opts?.isPublic,
     }, { aunPath: opts?.aunPath });
     if (!completeResult.ok) {
         return { ok: false, objectKey: remotePath, error: rpcErrorToString(completeResult.error) };
@@ -56,7 +56,7 @@ export async function storageUpload(aid, localFile, remotePath, opts) {
         if (!publicUrl) {
             const ticketResult = await rpcCall(aid, 'storage.create_download_ticket', {
                 object_key: remotePath,
-                expire_in_seconds: 86400 * 30, // 30天
+                expire_in_seconds: 86400 * 30,
             }, { aunPath: opts?.aunPath });
             if (ticketResult.ok) {
                 publicUrl = pickUrl(ticketResult.result?.url) ?? pickUrl(ticketResult.result?.download_url);
@@ -66,3 +66,12 @@ export async function storageUpload(aid, localFile, remotePath, opts) {
     }
     return { ok: true, objectKey: remotePath, publicUrl };
 }
+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/index.js

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