@agentunion/fastaun 0.5.21 → 0.5.23

package/dist/tools/cross-sdk-agent.js

@@ -5,6 +5,7 @@ import * as crypto from 'node:crypto';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { tmpdir } from 'node:os';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { URL } from 'node:url';
 import { fileURLToPath } from 'node:url';
 import { AUNClient } from '../client.js';
@@ -15,6 +16,32 @@ import { VERSION } from '../version.js';
 import { canonicalJson, digest, buildRequestBinding, verifyMembershipBinding, ProtocolError } from '../org-protocol.js';
 import { ownershipTaskResult } from '../ownership-workflow.js';
 import { TimeoutError } from '../errors.js';
+const credentialProcessStartupId = crypto.randomUUID();
+const cacheReadContext = new AsyncLocalStorage();
+const cacheReadObservers = new WeakMap();
+function acquireCacheReadObserver(target, key, wrap) {
+    let observers = cacheReadObservers.get(target);
+    if (!observers) {
+        observers = new Map();
+        cacheReadObservers.set(target, observers);
+    }
+    let observer = observers.get(key);
+    if (!observer) {
+        const original = target[key];
+        target[key] = wrap(original);
+        observer = { users: 0, restore: () => { target[key] = original; } };
+        observers.set(key, observer);
+    }
+    observer.users += 1;
+    return () => {
+        if (--observer.users === 0) {
+            observer.restore();
+            observers.delete(key);
+            if (!observers.size)
+                cacheReadObservers.delete(target);
+        }
+    };
+}
 function envBool(name, fallback = false) {
     const raw = process.env[name];
     if (raw == null)
@@ -136,6 +163,13 @@ export class CrossSdkTsAgent {
     eventBoundClients = new WeakSet();
     batchEventClient;
     batchEventHandlers = [];
+    p2pSubscription = true;
+    p2pEventClient;
+    p2pEventHandler;
+    p2pDeliveryPaused = false;
+    p2pDeliveryBlocked = 0;
+    p2pDeliveryGate = null;
+    p2pDeliveryRetiredClients = new WeakSet();
     rpcSpans = [];
     observationGeneration = 0;
     pullBarrier = null;
@@ -155,6 +189,18 @@ export class CrossSdkTsAgent {
     constructor() {
         this.client = this.newClient();
     }
+    credentialStartup;
+    credentialProcessId = credentialProcessStartupId;
+    credentialProcessCheckpoint() {
+        const internal = this.client;
+        const metadata = internal._tokenStore._loadMetadataStrict(this.aid) ?? {};
+        return structuredClone({ pid: process.pid, startup_uuid: this.credentialProcessId, aid: this.aid,
+            cert_fingerprint: this.client.currentAid?.certFingerprint, store: this.aunPath,
+            records: metadata.credential_renewals_v1 ?? {}, revocations: metadata.credential_revocations_v1 ?? { version: 1, authorities: {} } });
+    }
+    captureCredentialStartup() {
+        this.credentialStartup ??= { ...this.credentialProcessCheckpoint(), phase: 'before_connect' };
+    }
     async start() {
         this.bindClientEvents();
         // Cross-SDK runner 需要先由显式 Tail 建立窗口证明；启动阶段不得遗留后台 Pull。
@@ -172,7 +218,7 @@ export class CrossSdkTsAgent {
     bindClientEvents() {
         this.eventBoundClients ??= new WeakSet();
         if (this.eventBoundClients.has(this.client)) {
-            this.setBatchEventMode(this.batchEventMode ?? false);
+            this.setP2pSubscription(this.p2pSubscription ?? true);
             return;
         }
         this.eventBoundClients.add(this.client);
@@ -182,10 +228,6 @@ export class CrossSdkTsAgent {
         this.client.on('_raw.group.message_created', (data) => this.storeRawPushObservation('_raw.group.message_created', 'group', 'legacy', data));
         this.client.on('_raw.group.v2.message_created', (data) => this.storeRawPushObservation('_raw.group.v2.message_created', 'group', 'v2', data));
         this.client.on('_raw.group.changed', (data) => this.storeRawGroupChangedObservation(data));
-        this.client.on('message.received', (msg) => {
-            this.countSingleEvent('message.received');
-            void this.storeApplicationEvent('message.received', msg);
-        });
         this.client.on('message.undecryptable', (msg) => {
             void this.storeInboxItem(this.normalizeMessage(msg, false, 'undecryptable'));
         });
@@ -219,7 +261,7 @@ export class CrossSdkTsAgent {
                 this.recordTrace(textOf(payload.org_id), { stage: event, payload });
             });
         }
-        this.setBatchEventMode(this.batchEventMode ?? false);
+        this.setP2pSubscription(this.p2pSubscription ?? true);
     }
     countSingleEvent(event) {
         this.singleEventCounts ??= { 'message.received': 0, 'group.message_created': 0, 'group.changed': 0 };
@@ -237,18 +279,78 @@ export class CrossSdkTsAgent {
         else if (event === 'group.changed')
             this.storeGroupChangedPublicEvent(value);
     }
+    setP2pSubscription(enabled) {
+        this.p2pSubscription = enabled;
+        if (this.p2pEventHandler && (this.p2pEventClient !== this.client || !enabled)) {
+            this.p2pEventClient?.off('message.received', this.p2pEventHandler);
+            this.p2pEventHandler = undefined;
+        }
+        this.p2pEventClient = this.client;
+        if (enabled && !this.p2pEventHandler) {
+            const client = this.client;
+            this.p2pEventHandler = async (msg) => {
+                if ((this.p2pDeliveryPaused || this.p2pDeliveryRetiredClients?.has(client)) && !await this.waitForP2pDelivery(client))
+                    return;
+                this.countSingleEvent('message.received');
+                await this.storeApplicationEvent('message.received', msg);
+            };
+            this.client.on('message.received', this.p2pEventHandler);
+        }
+        this.setBatchEventMode(this.batchEventMode ?? false);
+    }
+    setP2pDeliveryPaused(paused) {
+        this.p2pDeliveryPaused = paused;
+        if (!paused) {
+            const gate = this.p2pDeliveryGate;
+            this.p2pDeliveryGate = null;
+            gate?.release();
+        }
+    }
+    async waitForP2pDelivery(client) {
+        if (this.p2pDeliveryRetiredClients?.has(client))
+            return false;
+        this.p2pDeliveryBlocked = (this.p2pDeliveryBlocked ?? 0) + 1;
+        try {
+            while (this.p2pDeliveryPaused && !this.p2pDeliveryRetiredClients?.has(client)) {
+                if (!this.p2pDeliveryGate) {
+                    let release;
+                    const promise = new Promise((resolve) => { release = resolve; });
+                    this.p2pDeliveryGate = { promise, release };
+                }
+                await this.p2pDeliveryGate.promise;
+            }
+            return !this.p2pDeliveryRetiredClients?.has(client);
+        }
+        finally {
+            this.p2pDeliveryBlocked -= 1;
+        }
+    }
+    retireP2pDelivery(client) {
+        this.p2pDeliveryRetiredClients ??= new WeakSet();
+        this.p2pDeliveryRetiredClients.add(client);
+        const gate = this.p2pDeliveryGate;
+        this.p2pDeliveryGate = null;
+        gate?.release();
+    }
+    applicationDeliveryState() {
+        const dispatcher = this.client._dispatcher;
+        return { subscribed: this.p2pSubscription ?? true, paused: this.p2pDeliveryPaused ?? false, blocked: this.p2pDeliveryBlocked ?? 0,
+            capacity: dispatcher?._messageQueueCapacity?.() ?? 0, used: dispatcher?._queuedMessageCount ?? 0, waiting: dispatcher?._messageAdmissionWaiters ?? 0 };
+    }
     setBatchEventMode(enabled) {
         this.batchEventMode = enabled;
-        if (enabled && this.batchEventClient === this.client && this.batchEventHandlers?.length)
+        const events = enabled ? ['message.batch', 'group.message_batch', 'group.event_batch'].filter((event) => event !== 'message.batch' || this.p2pSubscription !== false) : [];
+        if (this.batchEventClient === this.client && this.batchEventHandlers?.length === events.length && this.batchEventHandlers.every((item, index) => item.event === events[index]))
             return;
         for (const { event, handler } of this.batchEventHandlers ?? [])
             this.batchEventClient?.off(event, handler);
         this.batchEventClient = this.client;
         this.batchEventHandlers = [];
-        if (!enabled)
-            return;
-        for (const event of ['message.batch', 'group.message_batch', 'group.event_batch']) {
+        const client = this.client;
+        for (const event of events) {
             const handler = async (value) => {
+                if (event === 'message.batch' && (this.p2pDeliveryPaused || this.p2pDeliveryRetiredClients?.has(client)) && !await this.waitForP2pDelivery(client))
+                    return;
                 const data = jsonObjectOf(value) ?? {};
                 const items = JSON.parse(JSON.stringify(jsonSafe(Array.isArray(data.items) ? data.items : [])));
                 this.batchEvents ??= [];
@@ -617,6 +719,7 @@ export class CrossSdkTsAgent {
     }
     async close() {
         this.resetObservationLedgers();
+        this.retireP2pDelivery(this.client);
         try {
             await this.client.close();
         }
@@ -628,7 +731,7 @@ export class CrossSdkTsAgent {
         const internal = this.client;
         const store = new AIDStore({
             aunPath: this.aunPath,
-            encryptionSeed: '',
+            encryptionSeed: process.env.AUN_TEST_ENCRYPTION_SEED || process.env.AUN_ENCRYPTION_SEED || '',
             slotId: this.slotId,
             debug: this.debug,
         });
@@ -661,6 +764,7 @@ export class CrossSdkTsAgent {
             throw new Error(`load identity failed: ${loaded.error.code}: ${loaded.error.message}`);
         }
         this.client.loadIdentity(loaded.data.aid);
+        this.captureCredentialStartup();
         const checked = await store.checkAgentMd(this.aid);
         const localEtag = checked.ok ? String(checked.data.local_etag ?? '').trim() : '';
         const remoteEtag = checked.ok ? String(checked.data.remote_etag ?? '').trim() : '';
@@ -886,10 +990,23 @@ export class CrossSdkTsAgent {
                 if ((body.pull_barrier_count !== undefined && (typeof body.pull_barrier_count !== 'number' || !Number.isSafeInteger(body.pull_barrier_count) || body.pull_barrier_count < 0)) ||
                     (body.pull_barrier_scope !== undefined && !['all', 'p2p'].includes(body.pull_barrier_scope)) ||
                     (body.observation_id !== undefined && typeof body.observation_id !== 'string') ||
-                    (body.release_pull_barrier !== undefined && typeof body.release_pull_barrier !== 'boolean')) {
+                    (body.release_pull_barrier !== undefined && typeof body.release_pull_barrier !== 'boolean') ||
+                    ['p2p_subscription', 'p2p_delivery_paused', 'preserve_observations'].some((key) => body[key] !== undefined && typeof body[key] !== 'boolean')) {
                     sendJson(res, 400, { ok: false, error_code: 'bad_request', error_message: 'invalid observation parameters' });
                     return;
                 }
+                if (typeof body.p2p_subscription === 'boolean')
+                    this.setP2pSubscription(body.p2p_subscription);
+                const p2pPullSpanIds = body.preserve_observations === true && body.p2p_subscription === false
+                    ? this.rpcSpans.filter((span) => span.method === 'message.pull' || span.method === 'message.v2.pull').map((span) => textOf(span.span_id)) : undefined;
+                if (typeof body.p2p_delivery_paused === 'boolean')
+                    this.setP2pDeliveryPaused(body.p2p_delivery_paused);
+                if (body.preserve_observations === true) {
+                    if (body.release_pull_barrier === true)
+                        this.releasePullBarrier();
+                    sendJson(res, 200, { ok: true, observation_id: this.rawPushObservationId, ...(p2pPullSpanIds !== undefined ? { p2p_pull_span_ids: p2pPullSpanIds } : {}) });
+                    return;
+                }
                 if (body.release_pull_barrier === true) {
                     this.releasePullBarrier();
                     sendJson(res, 200, { ok: true, observation_id: this.rawPushObservationId });
@@ -954,6 +1071,7 @@ export class CrossSdkTsAgent {
                     rpcMethodCounts[method] = Number(rpcMethodCounts[method] ?? 0) + 1;
                 sendJson(res, 200, {
                     ok: true, time_ms: Date.now(), items, count: items.length, rpc_methods: rpcMethods, rpc_method_counts: rpcMethodCounts,
+                    observation_id: this.rawPushObservationId,
                     rpc_calls: rpcEntries,
                     group_changed_events: groupChangedEvents.slice(-limit),
                     group_invite_events: groupInviteEvents.slice(-limit),
@@ -964,6 +1082,7 @@ export class CrossSdkTsAgent {
                     batch_event_mode: this.batchEventMode ?? false,
                     batch_events: batchEvents,
                     single_event_counts: this.singleEventCounts ?? { 'message.received': 0, 'group.message_created': 0, 'group.changed': 0 },
+                    application_delivery: this.applicationDeliveryState(),
                     pull_barrier: { target: this.pullBarrier?.target ?? 0, waiting: this.pullBarrier?.waiting ?? 0, released: this.pullBarrier?.released ?? true, scope: this.pullBarrier?.scope ?? 'all' },
                 });
                 return;
@@ -1584,6 +1703,7 @@ export class CrossSdkTsAgent {
         try {
             if (typeof body.batch_events === 'boolean')
                 this.batchEventMode = body.batch_events;
+            this.retireP2pDelivery(this.client);
             await this.client.close();
             this.client = this.newClient();
             this.bindClientEvents();
@@ -1660,15 +1780,36 @@ export class CrossSdkTsAgent {
         const now = Math.floor(Date.now() / 1000);
         if (op === 'request')
             return buildRequestBinding(textOf(params.method), textOf(params.target), params.params, textOf(params.credential_cid), textOf(params.nonce), textOf(params.request_id), now, now + 300);
-        if (['register', 'sign', 'certificate', 'create', 'prepare'].includes(op)) {
+        if (op === 'revocation_checkpoint') {
+            const internal = this.client;
+            if (params.sync === true)
+                await internal._getCredentialRenewal()._syncRevocations();
+            return internal._tokenStore._loadMetadataStrict(this.aid)?.credential_revocations_v1 ?? { version: 1, authorities: {} };
+        }
+        if (op === 'credential_process')
+            return params.startup === true ? this.credentialStartup : this.credentialProcessCheckpoint();
+        if (op === 'manage_credential') {
+            const manager = this.client._getCredentialRenewal();
+            await manager.serial(() => manager.rememberNow(params.credential, {}, this.aid, undefined, true));
+            return await this.client.credential.current(textOf(params.credential.cid));
+        }
+        if (op === 'current_credential')
+            return await this.client.credential.current(textOf(params.credential_cid));
+        if (['register', 'sign', 'certificate', 'local_certificate', 'create', 'prepare', 'transfer_accept', 'renew'].includes(op)) {
             const store = this.aidStore();
             try {
-                if (op === 'prepare') {
+                if (op === 'transfer_accept')
+                    return await this.client.org.lifecycle.transferAccept({ ...jsonObjectOf(params.params), aidStore: store });
+                if (op === 'prepare' || op === 'renew') {
                     const request = jsonObjectOf(params.params) ?? {};
                     const orgId = textOf(params.org_id ?? request.org_id);
                     const loaded = orgId ? store.load(orgId) : null;
                     const orgSigner = loaded?.ok && loaded.data.aid.isPrivateKeyValid() ? loaded.data.aid : undefined;
-                    return this.client.org.prepareRequest(textOf(params.method), request, textOf(params.target), this.client.currentAid, { ...jsonObjectOf(params.options), orgSigner });
+                    const credentialOptions = jsonObjectOf(params.credential_options);
+                    if (op === 'prepare')
+                        return this.client.org.prepareRequest(textOf(params.method), request, textOf(params.target), this.client.currentAid, { ...jsonObjectOf(params.options), orgSigner, ...(credentialOptions ? { credentialOptions } : {}) });
+                    const prepared = this.client.org.prepareRequest('org.member.renewCredential', request, textOf(params.target) || `org.${orgId.slice(orgId.indexOf('.') + 1)}`, this.client.currentAid, { orgSigner, credentialOptions: jsonObjectOf(params.credential_options) ?? undefined });
+                    return { result: await this.client.org.member.renewCredential(prepared), params: prepared };
                 }
                 if (op === 'register') {
                     const registered = await store.register(textOf(params.org_id), { type: 'org', owner: this.aid, exttype: 'company' });
@@ -1677,12 +1818,14 @@ export class CrossSdkTsAgent {
                 }
                 const loaded = op === 'certificate'
                     ? await store.resolve(textOf(params.as_aid), { skipAgentMd: true })
-                    : (params.as_aid || params.org_id) ? store.load(textOf(params.as_aid ?? params.org_id)) : null;
+                    : (params.as_aid || op === 'local_certificate' || params.org_id) ? store.load(textOf(params.as_aid ?? params.org_id)) : null;
                 if (loaded && !loaded.ok)
                     throw new Error(String(loaded.error));
                 const identity = loaded?.data?.aid ?? this.client.currentAid;
                 const result = { cert_fingerprint: identity.certFingerprint, certificate: identity.certPem };
-                if (op === 'sign') {
+                if (op === 'local_certificate')
+                    result.has_private_key = identity.isPrivateKeyValid();
+                else if (op === 'sign') {
                     const signed = await identity.sign(Buffer.from(canonicalJson(params.payload)));
                     if (!signed.ok)
                         throw new Error(String(signed.error));
@@ -1710,6 +1853,7 @@ export class CrossSdkTsAgent {
                     const actual = jsonObjectOf(params.context) ?? params;
                     const memberships = jsonObjectOf(params.memberships) ?? {};
                     result.verification = { ...this.client.credential.verify(value, { resolveCertificate: resolver, resolveActorCertificate: resolver,
+                            resolveStatusProof: (cid) => params.status_proofs?.[cid],
                             resolveStatus: (cid) => params.statuses?.[cid], now: verificationNow, audience: textOf(actual.audience), subject: textOf(actual.subject) || undefined,
                             ns: textOf(actual.ns), action: textOf(actual.action), resource: textOf(actual.resource), rootIssuer: textOf(actual.root_issuer) || undefined,
                             params: jsonObjectOf(actual.params) ?? {}, units: jsonObjectOf(actual.units) ?? {}, clientIp: textOf(actual.client_ip), method: textOf(actual.method), target: textOf(actual.target),
@@ -1751,6 +1895,18 @@ export class CrossSdkTsAgent {
                 case 'sdk.org.protocol':
                     result = await this.orgProtocol(params);
                     break;
+                case 'credential.register':
+                    result = await this.client.credential.register(params);
+                    break;
+                case 'credential.status':
+                    result = await this.client.credential.status(params);
+                    break;
+                case 'credential.revoke':
+                    result = await this.client.credential.revoke(params);
+                    break;
+                case 'credential.revocationList':
+                    result = await this.client.credential.revocationList(params);
+                    break;
                 case 'org.lifecycle.create':
                     result = await this.client.org.lifecycle.create(params);
                     break;
@@ -1843,6 +1999,10 @@ export class CrossSdkTsAgent {
                 error_code: err instanceof Error ? err.name : 'Error',
                 error_message: err instanceof Error ? err.message : String(err),
             };
+            if (method.startsWith('org.') || method === 'sdk.org.protocol') {
+                const remote = err;
+                error.rpc_error_code = remote?.stringCode || remote?.data?.error_code || remote?.data?.code || (typeof remote?.code === 'string' ? remote.code : '');
+            }
             this.recordTrace(traceId, { stage: 'group_call_error', method, error });
             sendJson(res, 500, error);
         }
@@ -2007,6 +2167,8 @@ export class CrossSdkTsAgent {
         }
     }
     async callGroupFsAction(action, params, asGroupAid = '') {
+        if (action === 'cache_read')
+            return await this.cacheRead(params, true, asGroupAid);
         const groupFs = this.client.group.fs;
         let signingStore = null;
         const withSigning = (source) => {
@@ -2146,7 +2308,124 @@ export class CrossSdkTsAgent {
         }
         return response;
     }
+    async cacheRead(params, group = false, asGroupAid = '') {
+        const operation = textOf(params.operation || 'read_bytes');
+        if (!['read_bytes', 'stat', 'lstat', 'list', 'ls', 'find', 'du', 'df'].includes(operation)) {
+            throw new Error(`unsupported cache read operation: ${operation}`);
+        }
+        const transport = this.client._transport;
+        const lowlevel = group ? this.client.group.fs.lowlevel : this.client.storage.lowlevel;
+        const counters = { rpc_count: 0, http_count: 0, body_transfers: 0, body_bytes: 0, methods: {}, wire_params: [] };
+        const releaseCall = acquireCacheReadObserver(transport, 'call', (originalCall) => (method, request, ...tail) => {
+            const context = cacheReadContext.getStore();
+            const counted = context && (method.startsWith('storage.') || method.startsWith('group.fs.'));
+            if (counted) {
+                context.rpc_count += 1;
+                context.methods[method] = (context.methods[method] || 0) + 1;
+                context.wire_params.push({ method, params: JSON.parse(JSON.stringify(request ?? {})) });
+            }
+            const pending = originalCall.call(transport, method, request, ...tail);
+            const observed = pending.then((result) => {
+                const payload = jsonObjectOf(result);
+                const content = payload?.content_base64 ?? payload?.content;
+                if (counted && !payload?.not_modified && typeof content === 'string') {
+                    context.body_transfers += 1;
+                    context.body_bytes += Buffer.from(content, 'base64').byteLength;
+                }
+                return result;
+            });
+            if (pending.cancel)
+                observed.cancel = () => pending.cancel();
+            return observed;
+        });
+        const releaseHttp = acquireCacheReadObserver(lowlevel, 'httpGet', (originalHttp) => async (...args) => {
+            const context = cacheReadContext.getStore();
+            if (context)
+                context.http_count += 1;
+            const data = await originalHttp.call(lowlevel, ...args);
+            if (context) {
+                context.body_transfers += 1;
+                context.body_bytes += data.byteLength;
+            }
+            return data;
+        });
+        const readOnce = async () => {
+            const remotePath = textOf(params.path);
+            const noCache = Boolean(params.no_cache ?? params.noCache);
+            if (group) {
+                const options = withoutKeys(params, ['operation', 'count', 'concurrent', 'no_cache']);
+                options.noCache = noCache;
+                if (operation !== 'read_bytes')
+                    return await this.callGroupFsAction(operation === 'list' ? 'ls' : operation, options, asGroupAid);
+                delete options.path;
+                const dst = this.writeTempText('', '.bin');
+                try {
+                    const result = await this.callGroupFsAction('cp', { ...options, src: remotePath, dst, force: true }, asGroupAid);
+                    const response = jsonObjectOf(result);
+                    return { content_base64: response.content_base64, size_bytes: response.size_bytes };
+                }
+                finally {
+                    fs.rmSync(dst, { force: true });
+                }
+            }
+            const storage = this.client.storage;
+            const options = {
+                owner: textOf(params.owner_aid ?? params.ownerAID).trim() || undefined,
+                bucket: textOf(params.bucket).trim() || 'default', noCache,
+            };
+            if (operation !== 'df')
+                options.token = textOf(params.token).trim() || undefined;
+            if (operation === 'read_bytes') {
+                const shareId = textOf(params.share_id ?? params.shareId).trim();
+                if (shareId) {
+                    const result = await storage.lowlevel.getByShare({ shareId, noCache });
+                    const data = result.download_url ? await storage.lowlevel.httpGet(textOf(result.download_url)) : Buffer.from(textOf(result.content_base64 ?? result.content), 'base64');
+                    return { content_base64: Buffer.from(data).toString('base64'), size_bytes: data.byteLength };
+                }
+                for (const key of ['offset', 'limit'])
+                    if (params[key] != null)
+                        options[key] = Number(params[key]);
+                const data = await storage.readBytes(remotePath, options);
+                return { content_base64: Buffer.from(data).toString('base64'), size_bytes: data.byteLength };
+            }
+            const fields = { list: ['page', 'size', 'marker', 'long', 'recursive'], find: ['name', 'mtime', 'page'], du: [] };
+            for (const key of fields[operation] ?? [])
+                if (params[key] != null)
+                    options[key] = params[key];
+            if (params.page_size != null || params.pageSize != null)
+                options.pageSize = Number(params.page_size ?? params.pageSize);
+            if (params.max_depth != null || params.maxDepth != null)
+                options.maxDepth = Number(params.max_depth ?? params.maxDepth);
+            if (params.node_type != null || params.nodeType != null)
+                options.nodeType = params.node_type ?? params.nodeType;
+            if (operation === 'find' && (params.size_expr != null || params.sizeExpr != null))
+                options.size = params.size_expr ?? params.sizeExpr;
+            const method = storage[operation === 'ls' ? 'list' : operation];
+            return await method.call(storage, ...(operation === 'df' ? [options] : [remotePath, options]));
+        };
+        try {
+            const count = Math.max(1, Number(params.count || 1));
+            const values = await cacheReadContext.run(counters, async () => {
+                if (params.concurrent)
+                    return await Promise.all(Array.from({ length: count }, () => readOnce()));
+                const items = [];
+                for (let index = 0; index < count; index += 1)
+                    items.push(await readOnce());
+                return items;
+            });
+            if (values.some((value) => stableStringify(value) !== stableStringify(values[0])))
+                throw new Error('cache_read returned inconsistent values');
+            const result = operation === 'read_bytes' ? jsonObjectOf(values[0]) : { value: values[0] };
+            return { ...result, ...counters };
+        }
+        finally {
+            releaseCall();
+            releaseHttp();
+        }
+    }
     async callStorageAction(action, params) {
+        if (action === 'cache_read')
+            return await this.cacheRead(params);
         const storage = this.client.storage;
         const path = textOf(params.path).trim();
         const owner = textOf(params.owner_aid ?? params.ownerAID).trim() || undefined;
@@ -2325,7 +2604,10 @@ export class CrossSdkTsAgent {
             case 'revoke_share_link':
                 return await storage.lowlevel.revokeShareLink({ shareId: textOf(params.share_id ?? params.shareId).trim() });
             case 'get_by_share': {
-                const result = await storage.lowlevel.getByShare({ shareId: textOf(params.share_id ?? params.shareId).trim() });
+                const result = await storage.lowlevel.getByShare({
+                    shareId: textOf(params.share_id ?? params.shareId).trim(),
+                    noCache: Boolean(params.no_cache ?? params.noCache),
+                });
                 const resultObj = jsonObjectOf(result);
                 const content = textOf(resultObj?.content);
                 if (content) {
@@ -2616,7 +2898,7 @@ export class CrossSdkTsAgent {
     aidStore() {
         return new AIDStore({
             aunPath: this.aunPath,
-            encryptionSeed: '',
+            encryptionSeed: process.env.AUN_TEST_ENCRYPTION_SEED || process.env.AUN_ENCRYPTION_SEED || '',
             slotId: this.slotId,
             debug: this.debug,
         });