@agentunion/fastaun 0.4.13 → 0.5.1

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

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import * as http from 'node:http';
+import * as https from 'node:https';
 import * as crypto from 'node:crypto';
 import * as fs from 'node:fs';
 import { URL } from 'node:url';
@@ -53,6 +54,22 @@ function textOf(value) {
 function jsonObjectOf(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
 }
+function withoutKeys(source, keys) {
+    const next = { ...source };
+    for (const key of keys)
+        delete next[key];
+    return next;
+}
+function accessTokenFromClient(client) {
+    const internals = client;
+    const direct = textOf(internals.accessToken ?? internals.access_token).trim();
+    if (direct)
+        return direct;
+    const identityToken = textOf(internals._identity?.access_token).trim();
+    if (identityToken)
+        return identityToken;
+    return textOf(internals._sessionParams?.access_token).trim();
+}
 function envelopeMetadata(data) {
     const e2ee = jsonObjectOf(data.e2ee);
     const protectedHeaders = jsonObjectOf(data.protected_headers) ?? jsonObjectOf(e2ee?.protected_headers);
@@ -295,6 +312,10 @@ class CrossSdkTsAgent {
                 await this.groupCreate(req, res);
                 return;
             }
+            if (req.method === 'POST' && url.pathname === '/group/call') {
+                await this.groupCall(req, res);
+                return;
+            }
             if (req.method === 'GET' && url.pathname === '/group/ready') {
                 await this.groupReady(url, res);
                 return;
@@ -311,6 +332,18 @@ class CrossSdkTsAgent {
                 await this.groupAck(req, res);
                 return;
             }
+            if (req.method === 'POST' && url.pathname === '/group/fs/call') {
+                await this.groupFsCall(req, res);
+                return;
+            }
+            if (req.method === 'POST' && url.pathname === '/collab/call') {
+                await this.collabCall(req, res);
+                return;
+            }
+            if (req.method === 'POST' && url.pathname === '/storage/call') {
+                await this.storageCall(req, res);
+                return;
+            }
             if (req.method === 'GET' && url.pathname === '/inbox') {
                 const traceId = textOf(url.searchParams.get('trace_id') ?? '');
                 const fromAid = textOf(url.searchParams.get('from') ?? '');
@@ -470,12 +503,18 @@ class CrossSdkTsAgent {
             name,
             visibility: textOf(body.visibility || 'private'),
         };
+        const groupName = textOf(body.group_name ?? body.groupName ?? '').trim();
+        if (groupName)
+            params.group_name = groupName;
         const joinMode = textOf(body.join_mode || '').trim();
         if (joinMode)
             params.join_mode = joinMode;
         try {
-            const createResult = await this.client.call('group.create', params);
+            const createResult = groupName
+                ? await this.client.createGroup(params)
+                : await this.client.call('group.create', params);
             const groupId = this.extractGroupId(createResult);
+            const groupAid = this.extractGroupAid(createResult);
             if (!groupId)
                 throw new Error(`group.create did not return group_id: ${JSON.stringify(jsonSafe(createResult))}`);
             const addResults = [];
@@ -493,6 +532,7 @@ class CrossSdkTsAgent {
                 ok: true,
                 trace_id: traceId,
                 group_id: groupId,
+                group_aid: groupAid,
                 create_result: jsonSafe(createResult),
                 add_results: addResults,
             };
@@ -510,6 +550,605 @@ class CrossSdkTsAgent {
             sendJson(res, 500, error);
         }
     }
+    async groupCall(req, res) {
+        const body = await readJson(req);
+        const traceId = textOf(body.trace_id || crypto.randomUUID().replace(/-/g, ''));
+        let method = textOf(body.method).trim();
+        const action = textOf(body.action).trim();
+        if (!method && action)
+            method = action.startsWith('group.') ? action : `group.${action}`;
+        const params = jsonObjectOf(body.params) ?? {};
+        if (!method) {
+            sendJson(res, 400, { ok: false, trace_id: traceId, error_code: 'bad_request', error_message: 'method is required' });
+            return;
+        }
+        try {
+            const result = await this.client.call(method, params);
+            const response = { ok: true, trace_id: traceId, method, result: jsonSafe(result) };
+            this.recordTrace(traceId, { stage: 'group_call', method, result: response });
+            sendJson(res, 200, response);
+        }
+        catch (err) {
+            const error = {
+                ok: false,
+                trace_id: traceId,
+                method,
+                error_code: err instanceof Error ? err.name : 'Error',
+                error_message: err instanceof Error ? err.message : String(err),
+            };
+            this.recordTrace(traceId, { stage: 'group_call_error', method, error });
+            sendJson(res, 500, error);
+        }
+    }
+    async groupFsCall(req, res) {
+        const body = await readJson(req);
+        const traceId = textOf(body.trace_id || crypto.randomUUID().replace(/-/g, ''));
+        const action = textOf(body.action).trim();
+        const params = jsonObjectOf(body.params) ?? {};
+        const asGroupAid = textOf(body.as_group_aid || body.asGroupAid || params.as_group_aid || params.asGroupAid).trim();
+        delete params.as_group_aid;
+        delete params.asGroupAid;
+        try {
+            const result = await this.callGroupFsAction(action, params, asGroupAid);
+            const response = { ok: true, trace_id: traceId, action, result: jsonSafe(result) };
+            this.recordTrace(traceId, { stage: 'group_fs_call', action, as_group_aid: asGroupAid, result: response });
+            sendJson(res, 200, response);
+        }
+        catch (err) {
+            const error = {
+                ok: false,
+                trace_id: traceId,
+                action,
+                error_code: err instanceof Error ? err.name : 'Error',
+                error_message: err instanceof Error ? err.message : String(err),
+            };
+            this.recordTrace(traceId, { stage: 'group_fs_call_error', action, as_group_aid: asGroupAid, error });
+            sendJson(res, 500, error);
+        }
+    }
+    async collabCall(req, res) {
+        const body = await readJson(req);
+        const traceId = textOf(body.trace_id || crypto.randomUUID().replace(/-/g, ''));
+        const action = textOf(body.action).trim();
+        const params = jsonObjectOf(body.params) ?? {};
+        try {
+            const result = await this.callCollabAction(action, params);
+            const response = { ok: true, trace_id: traceId, action, result: jsonSafe(result) };
+            this.recordTrace(traceId, { stage: 'collab_call', action, result: response });
+            sendJson(res, 200, response);
+        }
+        catch (err) {
+            const error = {
+                ok: false,
+                trace_id: traceId,
+                action,
+                error_code: err instanceof Error ? err.name : 'Error',
+                error_message: err instanceof Error ? err.message : String(err),
+            };
+            this.recordTrace(traceId, { stage: 'collab_call_error', action, error });
+            sendJson(res, 500, error);
+        }
+    }
+    async storageCall(req, res) {
+        const body = await readJson(req);
+        const traceId = textOf(body.trace_id || crypto.randomUUID().replace(/-/g, ''));
+        const action = textOf(body.action).trim();
+        const params = jsonObjectOf(body.params) ?? {};
+        try {
+            const result = await this.callStorageAction(action, params);
+            const response = { ok: true, trace_id: traceId, action, result: jsonSafe(result) };
+            this.recordTrace(traceId, { stage: 'storage_call', action, result: response });
+            sendJson(res, 200, response);
+        }
+        catch (err) {
+            const error = {
+                ok: false,
+                trace_id: traceId,
+                action,
+                error_code: err instanceof Error ? err.name : 'Error',
+                error_message: err instanceof Error ? err.message : String(err),
+            };
+            this.recordTrace(traceId, { stage: 'storage_call_error', action, error });
+            sendJson(res, 500, error);
+        }
+    }
+    async callCollabAction(action, params) {
+        const collabRoot = textOf(params.collab_root ?? params.collabRoot);
+        const doc = textOf(params.doc);
+        const source = textOf(params.source);
+        switch (action) {
+            case 'ls':
+            case 'ls-files':
+                return await this.client.collab.lsFiles(collabRoot);
+            case 'create':
+                return await this.client.collab.create(collabRoot, doc, source);
+            case 'read':
+                return await this.client.collab.show(collabRoot, doc);
+            case 'show':
+                return await this.client.collab.show(collabRoot, doc, params.rev == null ? undefined : Number(params.rev) || 0);
+            case 'submit':
+                return await this.client.collab.commit(collabRoot, doc, source, Number(params.onto ?? params.base_version ?? params.baseVersion ?? 0) || 0, textOf(params.message) || '');
+            case 'commit':
+                return await this.client.collab.commit(collabRoot, doc, source, Number(params.onto ?? params.base_version ?? params.baseVersion ?? 0) || 0, textOf(params.message) || '');
+            case 'merge':
+                return await this.client.collab.merge(collabRoot, doc, source, Number(params.onto ?? params.base_version ?? params.baseVersion ?? 0) || 0);
+            case 'history':
+            case 'log':
+                return await this.client.collab.log(collabRoot, doc);
+            case 'get':
+                return await this.client.collab.show(collabRoot, doc, Number(params.version ?? 0) || 0);
+            case 'diff':
+                return await this.client.collab.diff(collabRoot, doc, Number(params.from ?? 0) || 0, Number(params.to ?? 0) || 0);
+            case 'export':
+                return await this.client.collab.clone(collabRoot, textOf(params.dest), false);
+            case 'adopt':
+                return await this.client.collab.clone(textOf(params.src), textOf(params.new_root ?? params.newRoot), true);
+            case 'clone':
+                return await this.client.collab.clone(textOf(params.src), textOf(params.dest), Boolean(params.reroot));
+            case 'prune':
+                return await this.client.collab.prune(collabRoot, doc);
+            case 'gc':
+                return await this.client.collab.gc(collabRoot, params.dry_run == null && params.dryRun == null ? true : Boolean(params.dry_run ?? params.dryRun));
+            case 'reflog':
+                return await this.client.collab.reflog(collabRoot, doc || undefined, Number(params.limit ?? 100) || 100);
+            case 'reset':
+                return await this.client.collab.revert(collabRoot, doc, Number(params.version ?? 0) || 0, textOf(params.message) || '');
+            case 'revert':
+                return await this.client.collab.revert(collabRoot, doc, Number(params.rev ?? params.version ?? 0) || 0, textOf(params.message) || '');
+            case 'discover':
+            case 'ls-remote':
+                return await this.client.collab.lsRemote(textOf(params.group_aid ?? params.groupAid));
+            case 'unregister':
+                return await this.client.collab.unregister(textOf(params.group_aid ?? params.groupAid), collabRoot);
+            case 'set_acl':
+                return await this.client.collab.setAcl(collabRoot, textOf(params.grantee_aid ?? params.granteeAID), {
+                    perms: textOf(params.perms || 'w'),
+                    expires_at: params.expires_at == null && params.expiresAt == null ? undefined : Number(params.expires_at ?? params.expiresAt),
+                    max_uses: params.max_uses == null && params.maxUses == null ? undefined : Number(params.max_uses ?? params.maxUses),
+                });
+            case 'remove_acl':
+                return await this.client.collab.removeAcl(collabRoot, textOf(params.grantee_aid ?? params.granteeAID));
+            case 'snapshot.create':
+            case 'tag.create':
+                return await this.client.collab.tag.create(collabRoot, {
+                    message: textOf(params.message),
+                    major: Boolean(params.major),
+                });
+            case 'snapshot.list':
+            case 'tag.list':
+                return await this.client.collab.tag.list(collabRoot);
+            case 'snapshot.show':
+            case 'tag.show':
+                return await this.client.collab.tag.show(collabRoot, textOf(params.version));
+            case 'snapshot.diff':
+            case 'tag.diff':
+                return await this.client.collab.tag.diff(collabRoot, textOf(params.version_a ?? params.versionA), textOf(params.version_b ?? params.versionB));
+            case 'snapshot.restore':
+            case 'tag.restore':
+                return await this.client.collab.tag.restore(collabRoot, textOf(params.version), { message: textOf(params.message) });
+            case 'snapshot.rm':
+            case 'tag.rm':
+                return await this.client.collab.tag.rm(collabRoot, textOf(params.version));
+            case 'snapshot.prune':
+            case 'tag.prune':
+                return await this.client.collab.tag.prune(collabRoot, {
+                    before: params.before == null ? null : Number(params.before),
+                    keep_last: params.keep_last == null && params.keepLast == null ? null : Number(params.keep_last ?? params.keepLast),
+                });
+            default:
+                throw new Error(`unsupported collab action: ${action}`);
+        }
+    }
+    async callGroupFsAction(action, params, asGroupAid = '') {
+        const groupFs = this.client.group.fs;
+        let signingStore = null;
+        const withSigning = (source) => {
+            const next = { ...source };
+            if (asGroupAid) {
+                signingStore ??= this.aidStore();
+                next.signAs = asGroupAid;
+                next.aidStore = signingStore;
+            }
+            return next;
+        };
+        const rawCall = async (method, source) => {
+            const payload = { ...source };
+            if (asGroupAid) {
+                signingStore ??= this.aidStore();
+                const loaded = await signingStore.load(asGroupAid);
+                if (!loaded.ok || !loaded.data?.aid) {
+                    throw new Error(loaded.error?.message || `signer identity not found: ${asGroupAid}`);
+                }
+                payload._client_signature_identity = loaded.data.aid;
+            }
+            return await this.client.call(method, payload);
+        };
+        const path = textOf(params.path).trim();
+        const options = withSigning(params);
+        delete options.path;
+        try {
+            switch (action) {
+                case 'ls':
+                    return await groupFs.ls(path, options);
+                case 'find':
+                    return await groupFs.find(path, options);
+                case 'stat':
+                    return await groupFs.stat(path, options);
+                case 'lstat':
+                    return await groupFs.lstat(path, options);
+                case 'mkdir':
+                    return await groupFs.mkdir(path, { ...options, parents: Boolean(params.parents) });
+                case 'set_acl':
+                    return await groupFs.setAcl(path, {
+                        ...options,
+                        grantee_aid: textOf(params.grantee_aid ?? params.granteeAid).trim() || 'role:admin',
+                        perms: textOf(params.perms).trim() || 'rwx',
+                    });
+                case 'remove_acl':
+                    return await groupFs.removeAcl(path, {
+                        ...options,
+                        grantee_aid: textOf(params.grantee_aid ?? params.granteeAid).trim() || 'role:admin',
+                    });
+                case 'get_acl':
+                    return await groupFs.getAcl(path, options);
+                case 'list_acl':
+                    return await groupFs.listAcl(path, options);
+                case 'rm':
+                    return await groupFs.rm(path, {
+                        ...options,
+                        recursive: Boolean(params.recursive),
+                        force: Boolean(params.force),
+                    });
+                case 'cp': {
+                    let src = textOf(params.src);
+                    const dst = textOf(params.dst);
+                    const cpOptions = withSigning(params);
+                    delete cpOptions.src;
+                    delete cpOptions.dst;
+                    delete cpOptions.src_text;
+                    if (params.src_text != null) {
+                        src = this.writeTempText(textOf(params.src_text), '.txt');
+                    }
+                    const result = await groupFs.cp(src, dst, cpOptions);
+                    return this.groupFsCpResponse(result, dst);
+                }
+                case 'mv':
+                    {
+                        const mvOptions = withSigning(params);
+                        delete mvOptions.src;
+                        delete mvOptions.dst;
+                        return await groupFs.mv(textOf(params.src), textOf(params.dst), mvOptions);
+                    }
+                case 'df':
+                    return await groupFs.df(path || textOf(params.group_id), options);
+                case 'mount':
+                    return await groupFs.mount(path, options);
+                case 'umount':
+                    return await groupFs.umount(path, options);
+                case 'raw':
+                    return await rawCall(textOf(params.method), withoutKeys(params, ['method']));
+                case 'check_upload':
+                    return await rawCall('group.fs.check_upload', params);
+                case 'create_upload_session':
+                    return await rawCall('group.fs.create_upload_session', params);
+                case 'complete_upload':
+                    return await rawCall('group.fs.complete_upload', params);
+                case 'create_download_ticket':
+                    return await rawCall('group.fs.create_download_ticket', params);
+                default:
+                    throw new Error(`unsupported group fs action: ${action}`);
+            }
+        }
+        finally {
+            const storeToClose = signingStore;
+            if (storeToClose)
+                storeToClose.close();
+        }
+    }
+    writeTempText(content, suffix = '') {
+        const root = textOf(process.env.AUN_CROSS_SDK_TMP || '/tmp/aun-cross-sdk');
+        fs.mkdirSync(root, { recursive: true });
+        const filePath = `${root}/${crypto.randomUUID()}${suffix}`;
+        fs.writeFileSync(filePath, content, 'utf-8');
+        return filePath;
+    }
+    groupFsCpResponse(result, dst) {
+        const response = { raw: jsonSafe(result) };
+        const resultObj = jsonObjectOf(result);
+        const data = resultObj?.data;
+        if (data instanceof ArrayBuffer) {
+            const buffer = Buffer.from(new Uint8Array(data));
+            response.content = buffer.toString('utf-8');
+            response.content_base64 = buffer.toString('base64');
+            response.size_bytes = buffer.byteLength;
+        }
+        else if (data instanceof Uint8Array || ArrayBuffer.isView(data)) {
+            const view = data;
+            const buffer = Buffer.from(view.buffer, view.byteOffset, view.byteLength);
+            response.content = buffer.toString('utf-8');
+            response.content_base64 = buffer.toString('base64');
+            response.size_bytes = buffer.byteLength;
+        }
+        const localPath = textOf(resultObj?.localPath ?? resultObj?.local_path ?? dst).trim();
+        if (localPath && fs.existsSync(localPath) && fs.statSync(localPath).isFile()) {
+            const buffer = fs.readFileSync(localPath);
+            response.local_path = localPath;
+            response.content = buffer.toString('utf-8');
+            response.content_base64 = buffer.toString('base64');
+            response.size_bytes = buffer.byteLength;
+        }
+        return response;
+    }
+    async callStorageAction(action, params) {
+        const storage = this.client.storage;
+        const path = textOf(params.path).trim();
+        const owner = textOf(params.owner_aid ?? params.ownerAID).trim() || undefined;
+        const bucket = textOf(params.bucket).trim() || 'default';
+        const token = textOf(params.token).trim() || undefined;
+        const src = textOf(params.src).trim();
+        const dst = textOf(params.dst).trim();
+        const objectKey = textOf(params.object_key ?? params.objectKey ?? path).replace(/^\/+/, '');
+        switch (action) {
+            case 'write_bytes':
+                return await storage.writeBytes(path, params.content_base64 || params.contentBase64
+                    ? Buffer.from(textOf(params.content), 'base64')
+                    : textOf(params.content), {
+                    owner,
+                    bucket,
+                    contentType: textOf(params.content_type ?? params.contentType).trim() || 'text/plain',
+                    public: Boolean(params.public),
+                    overwrite: params.overwrite == null ? false : Boolean(params.overwrite),
+                });
+            case 'read_bytes': {
+                const data = await storage.readBytes(path, { owner, bucket, token });
+                return {
+                    content: Buffer.from(data).toString('utf-8'),
+                    content_base64: Buffer.from(data).toString('base64'),
+                    size_bytes: data.byteLength,
+                };
+            }
+            case 'create_download_ticket': {
+                return await storage.lowlevel.createDownloadTicket({ owner, bucket, objectKey, token });
+            }
+            case 'download_text': {
+                const url = textOf(params.url ?? params.download_url ?? params.downloadUrl).trim();
+                if (!url)
+                    throw new Error('download_text requires url');
+                return { content: await downloadText(url, accessTokenFromClient(this.client)) };
+            }
+            case 'set_acl':
+                return await storage.setAcl(path, {
+                    owner,
+                    bucket,
+                    granteeAid: textOf(params.grantee_aid ?? params.granteeAID).trim(),
+                    perms: textOf(params.perms).trim(),
+                    expiresAt: params.expires_at == null && params.expiresAt == null ? undefined : Number(params.expires_at ?? params.expiresAt),
+                    maxUses: params.max_uses == null && params.maxUses == null ? undefined : Number(params.max_uses ?? params.maxUses),
+                });
+            case 'remove_acl':
+                return await storage.removeAcl(path, {
+                    owner,
+                    bucket,
+                    granteeAid: textOf(params.grantee_aid ?? params.granteeAID).trim(),
+                });
+            case 'list':
+                return await storage.list(path, {
+                    owner,
+                    bucket,
+                    page: Number(params.page ?? 1) || 1,
+                    size: Number(params.size ?? 100) || 100,
+                    marker: textOf(params.marker).trim() || undefined,
+                    long: Boolean(params.long),
+                    recursive: Boolean(params.recursive),
+                    token,
+                });
+            case 'find':
+                return await storage.find(path, {
+                    owner,
+                    bucket,
+                    name: textOf(params.name).trim() || undefined,
+                    nodeType: textOf(params.node_type ?? params.nodeType).trim() || undefined,
+                    size: textOf(params.size_expr ?? params.sizeExpr).trim() || undefined,
+                    mtime: textOf(params.mtime).trim() || undefined,
+                    page: Number(params.page ?? 1) || 1,
+                    pageSize: Number(params.page_size ?? params.pageSize ?? 1000) || 1000,
+                    token,
+                });
+            case 'stat':
+                return await storage.stat(path, { owner, bucket, token });
+            case 'lstat':
+                return await storage.lstat(path, { owner, bucket, token });
+            case 'mkdir':
+                return await storage.mkdir(path, { owner, bucket, parents: Boolean(params.parents) });
+            case 'touch':
+                return await storage.touch(path, {
+                    owner,
+                    bucket,
+                    parents: Boolean(params.parents),
+                    noCreate: Boolean(params.no_create ?? params.noCreate),
+                    mtime: params.mtime == null ? undefined : Number(params.mtime),
+                    followSymlinks: Boolean(params.follow_symlinks ?? params.followSymlinks),
+                });
+            case 'remove':
+                return await storage.remove(path, { owner, bucket, recursive: Boolean(params.recursive) });
+            case 'rename':
+                return await storage.rename(src, dst, {
+                    owner,
+                    bucket,
+                    overwrite: Boolean(params.overwrite),
+                    expectedVersion: params.expected_version == null && params.expectedVersion == null ? undefined : Number(params.expected_version ?? params.expectedVersion),
+                });
+            case 'copy':
+                return await storage.copy(src, dst, {
+                    owner,
+                    bucket,
+                    dstOwner: textOf(params.dst_owner_aid ?? params.dstOwnerAID ?? params.dstOwner).trim() || undefined,
+                    dstBucket: textOf(params.dst_bucket ?? params.dstBucket).trim() || undefined,
+                    overwrite: Boolean(params.overwrite),
+                    followSymlinks: Boolean(params.follow_symlinks ?? params.followSymlinks),
+                    recursive: Boolean(params.recursive),
+                });
+            case 'df':
+                return await storage.df({ owner, bucket });
+            case 'du':
+                return await storage.du(path, {
+                    owner,
+                    bucket,
+                    maxDepth: params.max_depth == null && params.maxDepth == null ? undefined : Number(params.max_depth ?? params.maxDepth),
+                    pageSize: Number(params.page_size ?? params.pageSize ?? 1000) || 1000,
+                    token,
+                });
+            case 'symlink':
+                return await storage.symlink(textOf(params.target), path, { owner, bucket, overwrite: Boolean(params.overwrite) });
+            case 'readlink':
+                return await storage.readlink(path, { owner, bucket });
+            case 'repoint':
+                return await storage.repoint(path, textOf(params.new_target ?? params.newTarget), {
+                    owner,
+                    bucket,
+                    expectedVersion: params.expected_version == null && params.expectedVersion == null ? undefined : Number(params.expected_version ?? params.expectedVersion),
+                });
+            case 'rename_symlink':
+                return await storage.renameSymlink(src, dst, {
+                    owner,
+                    bucket,
+                    overwrite: Boolean(params.overwrite),
+                    expectedVersion: params.expected_version == null && params.expectedVersion == null ? undefined : Number(params.expected_version ?? params.expectedVersion),
+                });
+            case 'delete_symlink':
+                return await storage.lowlevel.deleteSymlink({ owner, bucket, path: objectKey });
+            case 'list_acl':
+                return await storage.listAcl(path, { owner, bucket });
+            case 'check_access':
+                return await storage.checkAccess(path, {
+                    owner,
+                    bucket,
+                    operation: textOf(params.operation).trim() || 'read',
+                    token,
+                    followSymlinks: params.follow_symlinks == null && params.followSymlinks == null ? true : Boolean(params.follow_symlinks ?? params.followSymlinks),
+                });
+            case 'issue_token':
+                return await storage.issueToken(path, {
+                    owner,
+                    bucket,
+                    expiresAt: params.expires_at == null && params.expiresAt == null ? undefined : Number(params.expires_at ?? params.expiresAt),
+                    maxReads: params.max_reads == null && params.maxReads == null ? undefined : Number(params.max_reads ?? params.maxReads),
+                });
+            case 'revoke_token':
+                return await storage.revokeToken(path, { owner, bucket, token: textOf(params.token) });
+            case 'list_tokens':
+                return await storage.listTokens(path, { owner, bucket });
+            case 'set_visibility': {
+                const allowRoles = Array.isArray(params.allow_roles) ? params.allow_roles.map((item) => textOf(item)) : (Array.isArray(params.allowRoles) ? params.allowRoles.map((item) => textOf(item)) : undefined);
+                return await storage.setVisibility(path, { owner, bucket, visibility: textOf(params.visibility).trim() || 'private', allowRoles });
+            }
+            case 'create_share_link': {
+                const allowedAids = Array.isArray(params.allowed_aids) ? params.allowed_aids.map((item) => textOf(item)) : (Array.isArray(params.allowedAids) ? params.allowedAids.map((item) => textOf(item)) : undefined);
+                return await storage.lowlevel.createShareLink({
+                    owner,
+                    bucket,
+                    objectKey,
+                    allowedAids,
+                    expireInSeconds: params.expire_in_seconds == null && params.expireInSeconds == null ? undefined : Number(params.expire_in_seconds ?? params.expireInSeconds),
+                    maxUses: params.max_uses == null && params.maxUses == null ? undefined : Number(params.max_uses ?? params.maxUses),
+                });
+            }
+            case 'list_share_links':
+                return await storage.lowlevel.listShareLinks({ owner, bucket, objectKey: objectKey || undefined });
+            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 resultObj = jsonObjectOf(result);
+                const content = textOf(resultObj?.content);
+                if (content) {
+                    try {
+                        const buffer = Buffer.from(content, 'base64');
+                        return { ...(resultObj ?? {}), content_text: buffer.toString('utf-8'), content_base64: buffer.toString('base64') };
+                    }
+                    catch {
+                        return result;
+                    }
+                }
+                return result;
+            }
+            case 'head_object':
+                return await storage.lowlevel.headObject({ owner, bucket, objectKey, token });
+            case 'list_objects':
+                return await storage.lowlevel.listObjects({
+                    owner,
+                    bucket,
+                    prefix: textOf(params.prefix),
+                    page: Number(params.page ?? 1) || 1,
+                    size: Number(params.size ?? 100) || 100,
+                    marker: textOf(params.marker).trim() || undefined,
+                });
+            case 'list_prefixes':
+                return await storage.lowlevel.listPrefixes({ owner, bucket, prefix: textOf(params.prefix), size: Number(params.size ?? 100) || 100 });
+            case 'delete_object':
+                return await storage.lowlevel.deleteObject({ owner, bucket, objectKey });
+            case 'set_object_meta':
+                return await storage.lowlevel.setObjectMeta({
+                    owner,
+                    bucket,
+                    objectKey,
+                    metadata: jsonObjectOf(params.metadata) ?? {},
+                    contentType: textOf(params.content_type ?? params.contentType).trim() || undefined,
+                    merge: params.merge == null ? true : Boolean(params.merge),
+                    expectedVersion: params.expected_version == null && params.expectedVersion == null ? undefined : Number(params.expected_version ?? params.expectedVersion),
+                });
+            case 'append_object':
+                return await storage.lowlevel.appendObject({
+                    owner,
+                    bucket,
+                    objectKey,
+                    content: params.content_base64 || params.contentBase64 ? Buffer.from(textOf(params.content), 'base64') : Buffer.from(textOf(params.content), 'utf-8'),
+                    contentType: textOf(params.content_type ?? params.contentType).trim() || undefined,
+                    metadata: jsonObjectOf(params.metadata) ?? undefined,
+                    expectedVersion: params.expected_version == null && params.expectedVersion == null ? undefined : Number(params.expected_version ?? params.expectedVersion),
+                    isPublic: Boolean(params.public ?? params.isPublic),
+                });
+            case 'create_folder':
+                return await storage.lowlevel.createFolder({ owner, bucket, path: objectKey, parents: Boolean(params.parents ?? params.mkdirs) });
+            case 'list_children':
+                return await storage.lowlevel.listChildren({
+                    owner,
+                    bucket,
+                    path: objectKey,
+                    nodeType: textOf(params.node_type ?? params.nodeType ?? params.type).trim() || 'all',
+                    page: Number(params.page ?? 1) || 1,
+                    size: Number(params.size ?? 50) || 50,
+                    orderBy: textOf(params.order_by ?? params.orderBy).trim() || undefined,
+                    order: textOf(params.order).trim() || undefined,
+                    includeMetadata: params.include_metadata == null && params.includeMetadata == null ? undefined : Boolean(params.include_metadata ?? params.includeMetadata),
+                    includeUrls: params.include_urls == null && params.includeUrls == null ? undefined : Boolean(params.include_urls ?? params.includeUrls),
+                });
+            case 'copy_object':
+                return await storage.lowlevel.copyObject({
+                    owner,
+                    bucket,
+                    srcPath: textOf(params.src_path ?? params.srcPath ?? src).replace(/^\/+/, ''),
+                    dstPath: textOf(params.dst_path ?? params.dstPath ?? dst).replace(/^\/+/, ''),
+                    overwrite: Boolean(params.overwrite),
+                });
+            case 'move_object':
+                return await storage.lowlevel.moveObject({
+                    owner,
+                    bucket,
+                    path: textOf(params.src_path ?? params.srcPath ?? src ?? objectKey).replace(/^\/+/, ''),
+                    dstParentPath: textOf(params.dst_parent_path ?? params.dstParentPath).replace(/^\/+/, '').replace(/\/+$/g, ''),
+                    newName: textOf(params.new_name ?? params.newName),
+                    overwrite: Boolean(params.overwrite),
+                    expectedVersion: params.expected_version == null && params.expectedVersion == null ? undefined : Number(params.expected_version ?? params.expectedVersion),
+                });
+            case 'batch_delete': {
+                const items = Array.isArray(params.items) ? params.items.filter((item) => item && typeof item === 'object' && !Array.isArray(item)) : [];
+                return await storage.lowlevel.batchDelete({ owner, bucket, items, recursive: Boolean(params.recursive) });
+            }
+            default:
+                throw new Error(`unsupported storage action: ${action}`);
+        }
+    }
     async groupReady(url, res) {
         const groupId = textOf(url.searchParams.get('group_id') ?? '').trim();
         const expected = textOf(url.searchParams.get('members') ?? this.aid)
@@ -664,6 +1303,74 @@ class CrossSdkTsAgent {
         }
         return '';
     }
+    extractGroupAid(result) {
+        if (!result || typeof result !== 'object' || Array.isArray(result))
+            return '';
+        const obj = result;
+        const group = jsonObjectOf(obj.group);
+        return textOf(group?.group_aid ?? obj.group_aid).trim();
+    }
+    aidStore() {
+        return new AIDStore({
+            aunPath: this.aunPath,
+            encryptionSeed: '',
+            slotId: this.slotId,
+            debug: this.debug,
+        });
+    }
+}
+function shouldForwardBearerOnRedirect(current, next) {
+    if (current.origin === next.origin)
+        return true;
+    const currentHost = current.hostname.toLowerCase();
+    const nextHost = next.hostname.toLowerCase();
+    if (!nextHost.startsWith('storage.'))
+        return false;
+    const issuer = nextHost.slice('storage.'.length);
+    return Boolean(issuer) && (currentHost === issuer || currentHost.endsWith(`.${issuer}`));
+}
+function downloadText(url, bearerToken = '', redirects = 0) {
+    return new Promise((resolve, reject) => {
+        const parsed = new URL(url);
+        const client = parsed.protocol === 'https:' ? https : http;
+        const headers = bearerToken ? { Authorization: `Bearer ${bearerToken}` } : undefined;
+        const options = parsed.protocol === 'https:'
+            ? { rejectUnauthorized: false, headers }
+            : { headers };
+        const req = client.get(parsed, options, (resp) => {
+            const status = resp.statusCode ?? 0;
+            const location = typeof resp.headers.location === 'string' ? resp.headers.location : '';
+            if ([301, 302, 303, 307, 308].includes(status) && location) {
+                resp.resume();
+                if (redirects >= 5) {
+                    reject(new Error(`download redirect limit exceeded url=${url}`));
+                    return;
+                }
+                const nextUrl = new URL(location, parsed).toString();
+                const nextBearer = bearerToken && shouldForwardBearerOnRedirect(parsed, new URL(nextUrl)) ? bearerToken : '';
+                downloadText(nextUrl, nextBearer, redirects + 1).then(resolve, reject);
+                return;
+            }
+            const chunks = [];
+            resp.on('data', (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+            resp.on('end', () => {
+                if (status < 200 || status >= 300) {
+                    reject(new Error(`download failed status=${status} url=${url}`));
+                    return;
+                }
+                const content = Buffer.concat(chunks).toString('utf-8');
+                if (!content) {
+                    reject(new Error(`download returned empty body status=${status} url=${url}`));
+                    return;
+                }
+                resolve(content);
+            });
+        });
+        req.setTimeout(20000, () => {
+            req.destroy(new Error('download timeout'));
+        });
+        req.on('error', reject);
+    });
 }
 async function main() {
     const agent = new CrossSdkTsAgent();