@cloudbase/manager-node 4.11.0-alpha.3 → 4.11.0-alpha.5

package/lib/function/index.js

@@ -488,22 +488,25 @@ class FunctionService {
      * @param {string} qualifier 需要删除的版本号，不填默认删除函数下全部版本。
      * @returns {Promise<IResponseInfo>}
      */
-    async deleteFunction({ name }) {
+    async deleteFunction(name) {
         var _a;
+        const funcName = typeof name === 'string'
+            ? name
+            : name === null || name === void 0 ? void 0 : name.name;
         const { namespace } = this.getFunctionConfig();
         // 检测是否绑定了 API 网关
         const accessService = this.environment.getAccessService();
         const res = await accessService.getAccessList({
-            name
+            name: funcName
         });
         // 删除绑定的 API 网关
         if (((_a = res === null || res === void 0 ? void 0 : res.APISet) === null || _a === void 0 ? void 0 : _a.length) > 0) {
             await accessService.deleteAccess({
-                name
+                name: funcName
             });
         }
-        await this.scfService.request('DeleteFunction', {
-            FunctionName: name,
+        return await this.scfService.request('DeleteFunction', {
+            FunctionName: funcName,
             Namespace: namespace
         });
     }
@@ -741,10 +744,13 @@ class FunctionService {
             // 注意：dnsCache 需要 'TRUE'/'FALSE' 字符串，在特殊处理阶段处理
             'intranetconfig': 'IntranetConfig',
         };
+        const { TopicId, LogsetId } = this.getClsServiceConfig();
         // 构建参数
         const params = {
             Namespace: namespace,
-            FunctionName: func.name
+            FunctionName: func.name,
+            ClsTopicId: TopicId,
+            ClsLogsetId: LogsetId
         };
         // 白名单字段自动转换（大小写不敏感，统一输出 PascalCase）
         for (const key of Object.keys(func)) {
@@ -1047,13 +1053,12 @@ class FunctionService {
     async deleteFunctionTrigger(name, triggerName) {
         const { namespace } = this.getFunctionConfig();
         try {
-            await this.scfService.request('DeleteTrigger', {
+            return await this.scfService.request('DeleteTrigger', {
                 FunctionName: name,
                 Namespace: namespace,
                 TriggerName: triggerName,
                 Type: 'timer'
             });
-            (0, utils_1.successLog)(`[${name}] 删除云函数触发器 ${triggerName} 成功！`);
         }
         catch (e) {
             throw new error_1.CloudBaseError(`[${name}] 删除触发器失败：${e.message}`);

package/lib/storage/index.js

@@ -617,21 +617,17 @@ class StorageService {
             Error
         };
     }
-    /**
-     * 获取文件存储权限
-     * READONLY：所有用户可读，仅创建者和管理员可写
-     * PRIVATE：仅创建者及管理员可读写
-     * ADMINWRITE：所有用户可读，仅管理员可写
-     * ADMINONLY：仅管理员可读写
-     * CUSTOM：自定义安全规则
-     * @returns {Promise<{ acl: AclType, rule?: IStorageAclRule }>}
-     */
-    async getStorageAcl() {
+    async getStorageAcl(options) {
         const { bucket, env } = this.getStorageConfig();
         const res = await this.tcbService.request('DescribeStorageSafeRule', {
             EnvId: env,
             Bucket: bucket
         });
+        // 默认行为：返回简单的 AclType（向后兼容）
+        if (!(options === null || options === void 0 ? void 0 : options.withRule)) {
+            return res.AclTag;
+        }
+        // 带规则模式：返回对象
         const result = { acl: res.AclTag };
         if (res.AclTag === 'CUSTOM' && res.Rule) {
             try {
@@ -730,6 +726,56 @@ class StorageService {
         }
         return fileList;
     }
+    /**
+     * 列出指定目录下的文件和子目录（不递归，只列当前层）
+     * 使用 COS Delimiter 参数实现
+     * @param {string} dirPath 目录路径，空字符串表示根目录
+     * @returns {Promise<{ files: IListFileInfo[], directories: string[] }>}
+     */
+    async listCurrentDirectory(dirPath = '') {
+        const { bucket, region } = this.getStorageConfig();
+        const cos = this.getCos();
+        const getBucket = util_1.default.promisify(cos.getBucket).bind(cos);
+        // 确保目录路径以 / 结尾（除了根目录）
+        let prefix = dirPath;
+        if (prefix && !prefix.endsWith('/')) {
+            prefix = prefix + '/';
+        }
+        const files = [];
+        const directories = [];
+        let marker = '';
+        let isTruncated = true;
+        while (isTruncated) {
+            const res = await getBucket({
+                Bucket: bucket,
+                Region: region,
+                Prefix: prefix,
+                Delimiter: '/', // 关键：使用分隔符，不递归子目录
+                MaxKeys: 1000,
+                Marker: marker
+            });
+            // 文件列表（不包含子目录）
+            if (res.Contents) {
+                // 过滤掉目录本身（Key === prefix 的情况）
+                const fileItems = res.Contents.filter((item) => item.Key !== prefix);
+                files.push(...fileItems);
+            }
+            // 子目录列表（CommonPrefixes）
+            if (res.CommonPrefixes) {
+                const dirs = res.CommonPrefixes.map((item) => item.Prefix);
+                directories.push(...dirs);
+            }
+            isTruncated = res.IsTruncated === 'true' || res.IsTruncated === true;
+            if (isTruncated) {
+                // 防止无限循环：如果 IsTruncated 为 true 但 NextMarker 为空，则跳出循环
+                if (!res.NextMarker) {
+                    break;
+                }
+                marker = res.NextMarker;
+            }
+        }
+        return { files, directories };
+    }
     /**
      * 遍历本地文件夹
      * 忽略不包含 dir 路径，即如果 ignore 匹配 dir，dir 也不会被忽略
@@ -862,6 +908,356 @@ class StorageService {
         });
         return res;
     }
+    // ===== 复制/移动/搜索方法 =====
+    /**
+     * 复制单个文件
+     * @param options.sourcePath 源文件路径（云端路径，如 images/a.jpg）
+     * @param options.destPath 目标文件路径（云端路径，如 backup/a.jpg）
+     * @param options.force 是否强制覆盖
+     * @param options.skipExisting 是否跳过已存在的文件
+     * @returns 复制结果
+     */
+    async copyFile(options) {
+        const { sourcePath, destPath, force = false, skipExisting = false } = options;
+        const { bucket, region } = this.getStorageConfig();
+        // 1. 检查源文件是否存在
+        let sourceFileInfo;
+        try {
+            sourceFileInfo = await this.getFileInfo(sourcePath);
+        }
+        catch (e) {
+            if (e.statusCode === 404 || e.code === 'NoSuchKey') {
+                throw new error_1.CloudBaseError(`源文件不存在: ${sourcePath}`, {
+                    code: 'SOURCE_NOT_FOUND'
+                });
+            }
+            throw e;
+        }
+        // 2. 检查目标文件是否存在
+        let destExists = false;
+        let destFileInfo = null;
+        try {
+            destFileInfo = await this.getFileInfo(destPath);
+            destExists = true;
+        }
+        catch (e) {
+            if (e.statusCode !== 404 && e.code !== 'NoSuchKey') {
+                throw e;
+            }
+        }
+        if (destExists) {
+            if (skipExisting) {
+                return {
+                    success: true,
+                    sourcePath,
+                    destPath,
+                    status: 'skipped',
+                    // COS SDK 返回的 Size 单位已经是 bytes
+                    size: (destFileInfo === null || destFileInfo === void 0 ? void 0 : destFileInfo.Size) ? parseInt(destFileInfo.Size, 10) : undefined
+                };
+            }
+            if (!force) {
+                throw new error_1.CloudBaseError(`目标文件已存在: ${destPath}`, {
+                    code: 'DEST_EXISTS'
+                });
+            }
+        }
+        // 3. 执行复制（使用 COS SDK putObjectCopy）
+        const cos = this.getCos();
+        const putObjectCopy = util_1.default.promisify(cos.putObjectCopy).bind(cos);
+        // CopySource 格式: {bucket}.cos.{region}.myqcloud.com/{key}
+        // 注意: key 需要 URL 编码
+        // cspell:ignore myqcloud
+        const copySource = `${bucket}.cos.${region}.myqcloud.com/${encodeURIComponent(sourcePath)}`;
+        const res = await putObjectCopy({
+            Bucket: bucket,
+            Region: region,
+            Key: destPath,
+            CopySource: copySource
+        });
+        if (res.statusCode !== 200) {
+            throw new error_1.CloudBaseError(`复制文件失败：${JSON.stringify(res)}`);
+        }
+        // 4. 返回复制结果
+        return {
+            success: true,
+            sourcePath,
+            destPath,
+            status: 'copied',
+            // COS SDK 返回的 Size 单位已经是 bytes
+            size: (sourceFileInfo === null || sourceFileInfo === void 0 ? void 0 : sourceFileInfo.Size) ? parseInt(sourceFileInfo.Size, 10) : undefined
+        };
+    }
+    /**
+     * 复制目录
+     * 遍历源目录下的所有文件，并行复制到目标目录
+     * @param options.sourcePath 源目录路径
+     * @param options.destPath 目标目录路径
+     * @param options.include 包含模式（glob 格式）
+     * @param options.exclude 排除模式（glob 格式）
+     * @param options.force 是否强制覆盖
+     * @param options.skipExisting 是否跳过已存在的文件
+     * @param options.parallel 并发数，默认 20
+     * @param options.onProgress 进度回调
+     * @returns 复制结果数组
+     */
+    async copyDirectory(options) {
+        const { sourcePath, destPath, include, exclude, force = false, skipExisting = false, parallel = 20, onProgress } = options;
+        // 1. 列出源目录所有文件
+        const sourceKey = this.getCloudKey(sourcePath);
+        const files = await this.walkCloudDir(sourceKey);
+        if (!files || !files.length) {
+            // 进一步检查目录是否存在（通过 listCurrentDirectory）
+            // 如果目录存在但为空，listCurrentDirectory 会返回空的 files 和 directories
+            // 如果目录不存在，COS 仍然返回成功但结果为空
+            // 这里通过检查源路径的父目录来判断
+            const parentPath = sourcePath.includes('/')
+                ? sourcePath.substring(0, sourcePath.lastIndexOf('/'))
+                : '';
+            const { directories } = await this.listCurrentDirectory(parentPath);
+            const dirExists = directories.some(d => {
+                const normalizedDir = d.endsWith('/') ? d.slice(0, -1) : d;
+                return normalizedDir === sourceKey.slice(0, -1) || normalizedDir === sourcePath;
+            });
+            if (dirExists) {
+                throw new error_1.CloudBaseError(`源目录为空: ${sourcePath}`, {
+                    code: 'SOURCE_EMPTY'
+                });
+            }
+            else {
+                throw new error_1.CloudBaseError(`源目录不存在: ${sourcePath}`, {
+                    code: 'SOURCE_NOT_FOUND'
+                });
+            }
+        }
+        // 2. 过滤文件（使用 micromatch）
+        let filteredFiles = files.filter(f => !f.Key.endsWith('/')); // 排除目录
+        if (include) {
+            const patterns = Array.isArray(include) ? include : [include];
+            filteredFiles = filteredFiles.filter(f => {
+                const relativePath = f.Key.replace(sourceKey, '');
+                return micromatch_1.default.isMatch(relativePath, patterns);
+            });
+        }
+        if (exclude) {
+            const patterns = Array.isArray(exclude) ? exclude : [exclude];
+            filteredFiles = filteredFiles.filter(f => {
+                const relativePath = f.Key.replace(sourceKey, '');
+                return !micromatch_1.default.isMatch(relativePath, patterns);
+            });
+        }
+        if (!filteredFiles.length) {
+            return [];
+        }
+        // 3. 构建复制任务
+        let copiedCount = 0;
+        let skippedCount = 0;
+        const destKey = destPath.endsWith('/') ? destPath : destPath + '/';
+        const tasks = filteredFiles.map(file => async () => {
+            const relativePath = file.Key.replace(sourceKey, '');
+            const targetPath = destKey + relativePath;
+            try {
+                const result = await this.copyFile({
+                    sourcePath: file.Key,
+                    destPath: targetPath,
+                    force,
+                    skipExisting
+                });
+                if (result.status === 'copied')
+                    copiedCount++;
+                if (result.status === 'skipped')
+                    skippedCount++;
+                onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                    copied: copiedCount,
+                    skipped: skippedCount,
+                    total: filteredFiles.length,
+                    currentFile: file.Key
+                });
+                return result;
+            }
+            catch (e) {
+                return {
+                    success: false,
+                    sourcePath: file.Key,
+                    destPath: targetPath,
+                    status: 'failed',
+                    error: e.message
+                };
+            }
+        });
+        // 4. 使用 AsyncTaskParallelController 并发执行
+        const controller = new parallel_1.AsyncTaskParallelController(parallel, 50);
+        controller.loadTasks(tasks);
+        return controller.run();
+    }
+    /**
+     * 移动文件（复制后删除源文件）
+     * 注意：移动操作是「复制 + 删除」的两步操作，如果删除失败，文件会同时存在于源和目标位置
+     * @param options 与 copyFile 相同的选项
+     * @returns 移动结果，如果删除源文件失败会在 error 字段说明
+     */
+    async moveFile(options) {
+        const result = await this.copyFile(options);
+        if (result.status === 'copied') {
+            // 复制成功后使用 COS SDK 直接删除源文件
+            const { bucket, region } = this.getStorageConfig();
+            const cos = this.getCos();
+            const deleteObject = util_1.default.promisify(cos.deleteObject).bind(cos);
+            // 注意：文件路径不需要用 getCloudKey()，getCloudKey() 会在末尾加 /，用于目录
+            const sourceKey = options.sourcePath;
+            try {
+                await deleteObject({
+                    Bucket: bucket,
+                    Region: region,
+                    Key: sourceKey
+                });
+            }
+            catch (e) {
+                // 删除失败时，文件已复制成功，返回结果但附带错误信息
+                return Object.assign(Object.assign({}, result), { error: `文件已复制但删除源文件失败: ${e.message}` });
+            }
+        }
+        return result;
+    }
+    /**
+     * 移动目录（复制后删除源目录）
+     * 注意：移动操作是「复制 + 删除」的两步操作，如果部分删除失败，文件会同时存在于源和目标位置
+     * @param options 与 copyDirectory 相同的选项
+     * @returns 移动结果数组，删除失败的文件会在对应结果的 error 字段说明
+     */
+    async moveDirectory(options) {
+        const results = await this.copyDirectory(options);
+        // 只删除复制成功的文件
+        const copiedFiles = results
+            .filter(r => r.status === 'copied')
+            .map(r => r.sourcePath);
+        if (copiedFiles.length > 0) {
+            // 使用 COS SDK deleteMultipleObject 批量删除源文件
+            const { bucket, region } = this.getStorageConfig();
+            const cos = this.getCos();
+            const deleteMultipleObject = util_1.default.promisify(cos.deleteMultipleObject).bind(cos);
+            // COS deleteMultipleObject 单次最多删除 1000 个对象，这里按 500 分片
+            const files = [...copiedFiles];
+            const total = Math.ceil(files.length / 500);
+            const sliceGroup = [];
+            for (let i = 0; i < total; i++) {
+                sliceGroup.push(files.splice(0, 500));
+            }
+            // 收集删除失败的文件
+            const deleteFailedFiles = new Map();
+            const tasks = sliceGroup.map(async (group) => {
+                try {
+                    const res = await deleteMultipleObject({
+                        Bucket: bucket,
+                        Region: region,
+                        Objects: group.map(file => ({ Key: file }))
+                    });
+                    // 检查部分删除失败的情况
+                    if (res.Error && res.Error.length > 0) {
+                        for (const err of res.Error) {
+                            deleteFailedFiles.set(err.Key, err.Message || 'Unknown error');
+                        }
+                    }
+                }
+                catch (e) {
+                    // 整批删除失败，记录所有文件
+                    for (const file of group) {
+                        deleteFailedFiles.set(file, e.message);
+                    }
+                }
+            });
+            await Promise.all(tasks);
+            // 将删除失败信息附加到对应的结果中
+            if (deleteFailedFiles.size > 0) {
+                for (const result of results) {
+                    if (result.status === 'copied' && deleteFailedFiles.has(result.sourcePath)) {
+                        result.error = `文件已复制但删除源文件失败: ${deleteFailedFiles.get(result.sourcePath)}`;
+                    }
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * 搜索文件和目录（只搜索当前目录，不递归）
+     * @param options.pattern 搜索模式（支持 glob 或正则表达式）
+     * @param options.path 搜索目录路径（不指定则搜索根目录）
+     * @param options.isRegex 是否为正则表达式模式
+     * @param options.fileType 文件类型过滤
+     * @param options.limit 限制返回数量，默认 100
+     * @param options.includeDetails 是否包含详细信息（大小、修改时间）
+     * @returns 搜索结果数组（包含文件和目录）
+     */
+    async searchFiles(options) {
+        const { pattern, path: searchPath = '', isRegex = false, fileType, limit = 100, includeDetails = true } = options;
+        // 构建匹配器
+        let matcher;
+        if (isRegex) {
+            // 正则表达式模式
+            // 安全检查：限制正则表达式长度和复杂度，防止 ReDoS 攻击
+            const MAX_REGEX_LENGTH = 200;
+            if (pattern.length > MAX_REGEX_LENGTH) {
+                throw new error_1.CloudBaseError(`正则表达式过长，最大允许 ${MAX_REGEX_LENGTH} 字符`, {
+                    code: 'PATTERN_TOO_LONG'
+                });
+            }
+            // 检测潜在的危险模式（嵌套量词）
+            const dangerousPatterns = /(\+|\*|\{[0-9,]+\})\s*(\+|\*|\?|\{[0-9,]+\})/;
+            if (dangerousPatterns.test(pattern)) {
+                throw new error_1.CloudBaseError('正则表达式包含潜在的危险模式（嵌套量词），可能导致性能问题', {
+                    code: 'PATTERN_DANGEROUS'
+                });
+            }
+            try {
+                const regex = new RegExp(pattern);
+                matcher = (name) => regex.test(name);
+            }
+            catch (e) {
+                throw new error_1.CloudBaseError(`正则表达式语法错误: ${e.message}`, {
+                    code: 'PATTERN_SYNTAX_ERROR'
+                });
+            }
+        }
+        else {
+            // Glob 模式 - 使用 micromatch
+            matcher = (name) => micromatch_1.default.isMatch(name, pattern);
+        }
+        const results = [];
+        // 只列出当前目录（使用 Delimiter，不递归）
+        const { files, directories } = await this.listCurrentDirectory(searchPath);
+        // 处理目录
+        for (const dir of directories) {
+            // 获取目录名（去掉末尾的 / 和前缀）
+            const dirPath = dir.endsWith('/') ? dir.slice(0, -1) : dir;
+            const dirName = dirPath.split('/').pop() || dirPath;
+            if (matcher(dirName)) {
+                results.push({
+                    key: dir,
+                    type: 'directory'
+                });
+            }
+        }
+        // 处理文件
+        let matchedFiles = files.filter(f => {
+            const basename = f.Key.split('/').pop() || f.Key;
+            return matcher(basename);
+        });
+        // 文件类型过滤
+        if (fileType) {
+            const ext = fileType.startsWith('.') ? fileType : `.${fileType}`;
+            matchedFiles = matchedFiles.filter(f => f.Key.toLowerCase().endsWith(ext.toLowerCase()));
+        }
+        for (const f of matchedFiles) {
+            results.push({
+                key: f.Key,
+                type: 'file',
+                size: includeDetails ? parseInt(f.Size, 10) : undefined,
+                lastModified: includeDetails ? new Date(f.LastModified).toISOString() : undefined
+            });
+        }
+        // 限制总数量
+        return results.slice(0, limit);
+    }
     /**
      * 获取 COS 配置
      */
@@ -1074,9 +1470,27 @@ __decorate([
 __decorate([
     (0, utils_1.preLazy)()
 ], StorageService.prototype, "walkCloudDirCustom", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "listCurrentDirectory", null);
 __decorate([
     (0, utils_1.preLazy)()
 ], StorageService.prototype, "putBucketWebsite", null);
 __decorate([
     (0, utils_1.preLazy)()
 ], StorageService.prototype, "getBucket", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "copyFile", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "copyDirectory", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "moveFile", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "moveDirectory", null);
+__decorate([
+    (0, utils_1.preLazy)()
+], StorageService.prototype, "searchFiles", null);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cloudbase/manager-node",
-    "version": "4.11.0-alpha.3",
+    "version": "4.11.0-alpha.5",
     "description": "The node manage service api for cloudbase.",
     "main": "lib/index.js",
     "scripts": {

package/types/function/index.d.ts

@@ -277,9 +277,9 @@ export declare class FunctionService {
      * @param {string} qualifier 需要删除的版本号，不填默认删除函数下全部版本。
      * @returns {Promise<IResponseInfo>}
      */
-    deleteFunction({ name }: {
-        name: any;
-    }): Promise<void>;
+    deleteFunction(name: string | {
+        name: string;
+    }): Promise<IResponseInfo>;
     /**
      * 批量删除云函数
      * @param {Object} options
@@ -404,7 +404,7 @@ export declare class FunctionService {
      * @param {string} triggerName 云函数触发器名称
      * @returns {Promise<IResponseInfo>}
      */
-    deleteFunctionTrigger(name: string, triggerName: string): Promise<void>;
+    deleteFunctionTrigger(name: string, triggerName: string): Promise<IResponseInfo>;
     batchDeleteTriggers(options: IFunctionBatchOptions): Promise<void>;
     /**
      * 下载云函数代码

package/types/storage/index.d.ts

@@ -66,6 +66,82 @@ export interface IStorageAclRule {
     /** 写权限规则，true 表示所有用户可写，字符串表示自定义规则表达式 */
     write: boolean | string;
 }
+/** 复制文件选项 */
+export interface ICopyOptions {
+    /** 源路径（云端路径，如 images/a.jpg） */
+    sourcePath: string;
+    /** 目标路径（云端路径，如 backup/a.jpg） */
+    destPath: string;
+    /** 是否强制覆盖已存在的文件 */
+    force?: boolean;
+    /** 是否跳过已存在的文件 */
+    skipExisting?: boolean;
+}
+/** 复制目录选项 */
+export interface ICopyDirectoryOptions extends ICopyOptions {
+    /** 包含模式（glob 格式） */
+    include?: string | string[];
+    /** 排除模式（glob 格式） */
+    exclude?: string | string[];
+    /** 并发数，默认 20 */
+    parallel?: number;
+    /** 进度回调 */
+    onProgress?: (info: ICopyProgress) => void;
+}
+/** 复制进度信息 */
+export interface ICopyProgress {
+    /** 已复制数量 */
+    copied: number;
+    /** 已跳过数量 */
+    skipped: number;
+    /** 总数量 */
+    total: number;
+    /** 当前正在处理的文件 */
+    currentFile: string;
+}
+/** 复制结果状态 */
+export type CopyStatus = 'copied' | 'skipped' | 'failed';
+/** 复制结果 */
+export interface ICopyResult {
+    /** 是否成功 */
+    success: boolean;
+    /** 源路径 */
+    sourcePath: string;
+    /** 目标路径 */
+    destPath: string;
+    /** 文件大小 (bytes) */
+    size?: number;
+    /** 复制状态 */
+    status: CopyStatus;
+    /** 失败时的错误信息 */
+    error?: string;
+}
+/** 搜索文件选项 */
+export interface ISearchOptions {
+    /** 搜索模式（glob 或正则表达式） */
+    pattern: string;
+    /** 搜索目录路径（不指定则搜索根目录） */
+    path?: string;
+    /** 是否为正则表达式 */
+    isRegex?: boolean;
+    /** 文件类型过滤（如 jpg, png） */
+    fileType?: string;
+    /** 限制数量，默认 100 */
+    limit?: number;
+    /** 是否包含详细信息 */
+    includeDetails?: boolean;
+}
+/** 搜索结果 */
+export interface ISearchResult {
+    /** 文件路径（云端路径） */
+    key: string;
+    /** 类型：file 或 directory */
+    type: 'file' | 'directory';
+    /** 文件大小 (bytes)，仅文件有效 */
+    size?: number;
+    /** 最后修改时间 (ISO 格式)，仅文件有效 */
+    lastModified?: string;
+}
 type OnProgress = (progressData: IProgressData) => void;
 type OnFileFinish = (error: Error, res: any, fileData: any) => void;
 export declare class StorageService {
@@ -227,9 +303,23 @@ export declare class StorageService {
      * ADMINWRITE：所有用户可读，仅管理员可写
      * ADMINONLY：仅管理员可读写
      * CUSTOM：自定义安全规则
-     * @returns {Promise<{ acl: AclType, rule?: IStorageAclRule }>}
-     */
-    getStorageAcl(): Promise<{
+     *
+     * @param options.withRule 是否返回自定义安全规则，默认 false 以保持向后兼容
+     * @returns 不传参数时返回 AclType（向后兼容），传入 { withRule: true } 时返回 { acl: AclType, rule?: IStorageAclRule }
+     *
+     * @example
+     * // 向后兼容的简单用法（返回 AclType）
+     * const acl = await storage.getStorageAcl()
+     * if (acl === 'READONLY') { ... }
+     *
+     * // 获取自定义安全规则（返回对象）
+     * const result = await storage.getStorageAcl({ withRule: true })
+     * console.log(result.acl, result.rule)
+     */
+    getStorageAcl(): Promise<AclType>;
+    getStorageAcl(options: {
+        withRule: true;
+    }): Promise<{
         acl: AclType;
         rule?: IStorageAclRule;
     }>;
@@ -270,6 +360,16 @@ export declare class StorageService {
      * @returns {Promise<IListFileInfo[]>}
      */
     walkCloudDirCustom(options: IWalkCloudDirOptions): Promise<IListFileInfo[]>;
+    /**
+     * 列出指定目录下的文件和子目录（不递归，只列当前层）
+     * 使用 COS Delimiter 参数实现
+     * @param {string} dirPath 目录路径，空字符串表示根目录
+     * @returns {Promise<{ files: IListFileInfo[], directories: string[] }>}
+     */
+    listCurrentDirectory(dirPath?: string): Promise<{
+        files: IListFileInfo[];
+        directories: string[];
+    }>;
     /**
      * 遍历本地文件夹
      * 忽略不包含 dir 路径，即如果 ignore 匹配 dir，dir 也不会被忽略
@@ -300,6 +400,54 @@ export declare class StorageService {
      * @memberof StorageService
      */
     getBucket(options: IGetBucketOpions): Promise<any>;
+    /**
+     * 复制单个文件
+     * @param options.sourcePath 源文件路径（云端路径，如 images/a.jpg）
+     * @param options.destPath 目标文件路径（云端路径，如 backup/a.jpg）
+     * @param options.force 是否强制覆盖
+     * @param options.skipExisting 是否跳过已存在的文件
+     * @returns 复制结果
+     */
+    copyFile(options: ICopyOptions): Promise<ICopyResult>;
+    /**
+     * 复制目录
+     * 遍历源目录下的所有文件，并行复制到目标目录
+     * @param options.sourcePath 源目录路径
+     * @param options.destPath 目标目录路径
+     * @param options.include 包含模式（glob 格式）
+     * @param options.exclude 排除模式（glob 格式）
+     * @param options.force 是否强制覆盖
+     * @param options.skipExisting 是否跳过已存在的文件
+     * @param options.parallel 并发数，默认 20
+     * @param options.onProgress 进度回调
+     * @returns 复制结果数组
+     */
+    copyDirectory(options: ICopyDirectoryOptions): Promise<ICopyResult[]>;
+    /**
+     * 移动文件（复制后删除源文件）
+     * 注意：移动操作是「复制 + 删除」的两步操作，如果删除失败，文件会同时存在于源和目标位置
+     * @param options 与 copyFile 相同的选项
+     * @returns 移动结果，如果删除源文件失败会在 error 字段说明
+     */
+    moveFile(options: ICopyOptions): Promise<ICopyResult>;
+    /**
+     * 移动目录（复制后删除源目录）
+     * 注意：移动操作是「复制 + 删除」的两步操作，如果部分删除失败，文件会同时存在于源和目标位置
+     * @param options 与 copyDirectory 相同的选项
+     * @returns 移动结果数组，删除失败的文件会在对应结果的 error 字段说明
+     */
+    moveDirectory(options: ICopyDirectoryOptions): Promise<ICopyResult[]>;
+    /**
+     * 搜索文件和目录（只搜索当前目录，不递归）
+     * @param options.pattern 搜索模式（支持 glob 或正则表达式）
+     * @param options.path 搜索目录路径（不指定则搜索根目录）
+     * @param options.isRegex 是否为正则表达式模式
+     * @param options.fileType 文件类型过滤
+     * @param options.limit 限制返回数量，默认 100
+     * @param options.includeDetails 是否包含详细信息（大小、修改时间）
+     * @returns 搜索结果数组（包含文件和目录）
+     */
+    searchFiles(options: ISearchOptions): Promise<ISearchResult[]>;
     /**
      * 获取 COS 配置
      */