@cloudbase/manager-node 5.1.1 → 5.2.0-beta.1

package/lib/environment.js

@@ -20,6 +20,7 @@ const cloudBaseRun_1 = require("./cloudBaseRun");
 const mysql_1 = require("./mysql");
 const cloudApp_1 = require("./cloudApp");
 const permission_1 = require("./permission");
+const sandbox_1 = require("./sandbox");
 class Environment {
     constructor(context, envId) {
         this.inited = false;
@@ -43,6 +44,7 @@ class Environment {
         this.mysqlService = new mysql_1.MysqlService(this);
         this.permissionService = new permission_1.PermissionService(this);
         this.cloudAppService = new cloudApp_1.CloudAppService(this);
+        this.sandboxService = new sandbox_1.SandboxService(this);
     }
     async lazyInit() {
         if (!this.inited) {
@@ -111,6 +113,9 @@ class Environment {
     getPermissionService() {
         return this.permissionService;
     }
+    getSandboxService() {
+        return this.sandboxService;
+    }
     getCommonService(serviceType = 'tcb', serviceVersion) {
         return new common_1.CommonService(this, serviceType, serviceVersion);
     }

package/lib/index.js

@@ -116,6 +116,9 @@ class CloudBase {
     get permission() {
         return this.currentEnvironment().getPermissionService();
     }
+    get sandbox() {
+        return this.currentEnvironment().getSandboxService();
+    }
     get docs() {
         if (!this.docsService) {
             this.docsService = new docs_1.DocsService();

package/lib/sandbox/index.js

@@ -0,0 +1,562 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxService = void 0;
+const utils_1 = require("../utils");
+class SandboxService {
+    constructor(environment) {
+        this.environment = environment;
+        this.agsService = new utils_1.CloudService(environment.cloudBaseContext, 'ags', '2025-09-20');
+    }
+    /**
+     * 更新沙箱工具
+     * 更新指定沙箱工具的描述、网络配置、标签和自定义配置等信息。
+     * @param {UpdateSandboxToolOptions} options 更新参数
+     * @returns {Promise<UpdateSandboxToolResp>}
+     */
+    async updateSandboxTool(options) {
+        const { toolId, description, networkConfiguration, tags, customConfiguration } = options;
+        // ToolId 校验：必填
+        if (typeof toolId !== 'string' || toolId.trim().length === 0) {
+            throw new Error('toolId is required');
+        }
+        // Description 校验：最大 200 字符
+        if (description !== undefined && description.length > 200) {
+            throw new Error('description length must be <= 200');
+        }
+        // NetworkConfiguration 校验
+        if (networkConfiguration !== undefined) {
+            const validModes = ['PUBLIC', 'VPC', 'SANDBOX'];
+            if (!networkConfiguration.NetworkMode || !validModes.includes(networkConfiguration.NetworkMode)) {
+                throw new Error(`NetworkMode must be one of: ${validModes.join(', ')}`);
+            }
+        }
+        // Tags 校验
+        if (tags !== undefined) {
+            if (!Array.isArray(tags)) {
+                throw new Error('tags must be an array');
+            }
+        }
+        // CustomConfiguration 校验
+        if (customConfiguration !== undefined) {
+            // Image 镜像地址格式基本校验
+            if (customConfiguration.Image !== undefined) {
+                if (typeof customConfiguration.Image !== 'string' || customConfiguration.Image.trim().length === 0) {
+                    throw new Error('Image must be a non-empty string');
+                }
+            }
+            // ImageRegistryType 校验
+            if (customConfiguration.ImageRegistryType !== undefined) {
+                const validTypes = ['enterprise', 'personal'];
+                if (!validTypes.includes(customConfiguration.ImageRegistryType)) {
+                    throw new Error(`ImageRegistryType must be one of: ${validTypes.join(', ')}`);
+                }
+            }
+            // Ports 校验
+            if (customConfiguration.Ports !== undefined) {
+                if (!Array.isArray(customConfiguration.Ports)) {
+                    throw new Error('Ports must be an array');
+                }
+            }
+            // Env 校验
+            if (customConfiguration.Env !== undefined) {
+                if (!Array.isArray(customConfiguration.Env)) {
+                    throw new Error('Env must be an array');
+                }
+            }
+            // DNSConfig.Servers 校验：文档标注为必填
+            if (customConfiguration.DNSConfig !== undefined) {
+                if (!Array.isArray(customConfiguration.DNSConfig.Servers) || customConfiguration.DNSConfig.Servers.length === 0) {
+                    throw new Error('DNSConfig.Servers is required and must be a non-empty array');
+                }
+            }
+        }
+        // 构造请求体
+        const reqData = {
+            ToolId: toolId
+        };
+        if (description !== undefined) {
+            reqData.Description = description;
+        }
+        if (networkConfiguration !== undefined) {
+            reqData.NetworkConfiguration = networkConfiguration;
+        }
+        if (tags !== undefined) {
+            reqData.Tags = tags;
+        }
+        if (customConfiguration !== undefined) {
+            reqData.CustomConfiguration = customConfiguration;
+        }
+        return this.agsService.request('UpdateSandboxTool', reqData);
+    }
+    /**
+     * 查询沙箱工具列表
+     * @param {DescribeSandboxToolListOptions} options 查询参数
+     * @returns {Promise<DescribeSandboxToolListResp>}
+     */
+    async describeSandboxToolList(options = {}) {
+        const { toolIds, offset, limit, filters } = options;
+        // ToolIds 校验
+        if (toolIds !== undefined) {
+            if (!Array.isArray(toolIds)) {
+                throw new Error('toolIds must be an array');
+            }
+            if (toolIds.length > 100) {
+                throw new Error('toolIds length must be <= 100');
+            }
+            const invalidId = toolIds.find(id => typeof id !== 'string' || id.trim().length === 0);
+            if (invalidId !== undefined) {
+                throw new Error('toolIds contains invalid item');
+            }
+        }
+        // Offset 校验
+        if (offset !== undefined && (!Number.isInteger(offset) || offset < 0)) {
+            throw new Error('offset must be a non-negative integer');
+        }
+        // Limit 校验
+        if (limit !== undefined && (!Number.isInteger(limit) || limit < 1 || limit > 100)) {
+            throw new Error('limit must be an integer between 1 and 100');
+        }
+        // Filters 校验
+        if (filters !== undefined) {
+            if (!Array.isArray(filters)) {
+                throw new Error('filters must be an array');
+            }
+        }
+        // 构造请求体
+        const reqData = {};
+        if (toolIds !== undefined && toolIds.length > 0) {
+            reqData.ToolIds = toolIds;
+        }
+        if (offset !== undefined) {
+            reqData.Offset = offset;
+        }
+        if (limit !== undefined) {
+            reqData.Limit = limit;
+        }
+        if (filters !== undefined && filters.length > 0) {
+            reqData.Filters = filters;
+        }
+        return this.agsService.request('DescribeSandboxToolList', reqData);
+    }
+    /**
+     * 创建沙箱工具
+     * @param {CreateSandboxToolOptions} options 创建参数
+     * @returns {Promise<CreateSandboxToolResp>}
+     */
+    async createSandboxTool(options) {
+        const { toolName, toolType, networkConfiguration, description, defaultTimeout, tags, clientToken, roleArn, storageMounts, customConfiguration, logConfiguration } = options;
+        // ToolName 校验：必填，1-50 字符，英文/数字/下划线/连接线
+        if (typeof toolName !== 'string' || toolName.trim().length === 0) {
+            throw new Error('toolName is required');
+        }
+        if (toolName.length > 50) {
+            throw new Error('toolName length must be <= 50');
+        }
+        if (!/^[a-zA-Z0-9_-]+$/.test(toolName)) {
+            throw new Error('toolName can only contain letters, digits, underscores and hyphens');
+        }
+        // ToolType 校验：必填，枚举
+        const validToolTypes = ['browser', 'code-interpreter', 'custom'];
+        if (!toolType || !validToolTypes.includes(toolType)) {
+            throw new Error(`toolType must be one of: ${validToolTypes.join(', ')}`);
+        }
+        // NetworkConfiguration 校验：必填
+        if (!networkConfiguration) {
+            throw new Error('networkConfiguration is required');
+        }
+        const validModes = ['PUBLIC', 'VPC', 'SANDBOX'];
+        if (!networkConfiguration.NetworkMode || !validModes.includes(networkConfiguration.NetworkMode)) {
+            throw new Error(`NetworkMode must be one of: ${validModes.join(', ')}`);
+        }
+        // Description 校验
+        if (description !== undefined && description.length > 200) {
+            throw new Error('description length must be <= 200');
+        }
+        // DefaultTimeout 校验：格式如 5m、300s、1h
+        if (defaultTimeout !== undefined) {
+            if (typeof defaultTimeout !== 'string' || !/^\d+[smh]$/.test(defaultTimeout)) {
+                throw new Error('defaultTimeout must match format like 5m, 300s, 1h');
+            }
+        }
+        // ClientToken 校验：最大 64 字符
+        if (clientToken !== undefined && clientToken.length > 64) {
+            throw new Error('clientToken length must be <= 64');
+        }
+        // Tags 校验
+        if (tags !== undefined) {
+            if (!Array.isArray(tags)) {
+                throw new Error('tags must be an array');
+            }
+        }
+        // StorageMounts 校验
+        if (storageMounts !== undefined) {
+            if (!Array.isArray(storageMounts)) {
+                throw new Error('storageMounts must be an array');
+            }
+        }
+        // CustomConfiguration 校验
+        if (customConfiguration !== undefined) {
+            if (customConfiguration.Image !== undefined) {
+                if (typeof customConfiguration.Image !== 'string' || customConfiguration.Image.trim().length === 0) {
+                    throw new Error('Image must be a non-empty string');
+                }
+            }
+            if (customConfiguration.ImageRegistryType !== undefined) {
+                const validTypes = ['enterprise', 'personal'];
+                if (!validTypes.includes(customConfiguration.ImageRegistryType)) {
+                    throw new Error(`ImageRegistryType must be one of: ${validTypes.join(', ')}`);
+                }
+            }
+            if (customConfiguration.DNSConfig !== undefined) {
+                if (!Array.isArray(customConfiguration.DNSConfig.Servers) || customConfiguration.DNSConfig.Servers.length === 0) {
+                    throw new Error('DNSConfig.Servers is required and must be a non-empty array');
+                }
+            }
+        }
+        // 构造请求体
+        const reqData = {
+            ToolName: toolName,
+            ToolType: toolType,
+            NetworkConfiguration: networkConfiguration
+        };
+        if (description !== undefined) {
+            reqData.Description = description;
+        }
+        if (defaultTimeout !== undefined) {
+            reqData.DefaultTimeout = defaultTimeout;
+        }
+        if (tags !== undefined) {
+            reqData.Tags = tags;
+        }
+        if (clientToken !== undefined) {
+            reqData.ClientToken = clientToken;
+        }
+        if (roleArn !== undefined) {
+            reqData.RoleArn = roleArn;
+        }
+        if (storageMounts !== undefined) {
+            reqData.StorageMounts = storageMounts;
+        }
+        if (customConfiguration !== undefined) {
+            reqData.CustomConfiguration = customConfiguration;
+        }
+        if (logConfiguration !== undefined) {
+            reqData.LogConfiguration = logConfiguration;
+        }
+        return this.agsService.request('CreateSandboxTool', reqData);
+    }
+    /**
+     * 删除沙箱工具
+     * @param {DeleteSandboxToolOptions} options 删除参数
+     * @returns {Promise<DeleteSandboxToolResp>}
+     */
+    async deleteSandboxTool(options) {
+        const { toolId } = options;
+        // ToolId 校验：必填
+        if (typeof toolId !== 'string' || toolId.trim().length === 0) {
+            throw new Error('toolId is required');
+        }
+        const reqData = {
+            ToolId: toolId
+        };
+        return this.agsService.request('DeleteSandboxTool', reqData);
+    }
+    /**
+     * 恢复沙箱实例
+     * @param {ResumeSandboxInstanceOptions} options 恢复参数
+     * @returns {Promise<ResumeSandboxInstanceResp>}
+     */
+    async resumeSandboxInstance(options) {
+        const { instanceId } = options;
+        // InstanceId 校验：必填
+        if (typeof instanceId !== 'string' || instanceId.trim().length === 0) {
+            throw new Error('instanceId is required');
+        }
+        const reqData = {
+            InstanceId: instanceId
+        };
+        return this.agsService.request('ResumeSandboxInstance', reqData);
+    }
+    /**
+     * 暂停沙箱实例
+     * @param {PauseSandboxInstanceOptions} options 暂停参数
+     * @returns {Promise<PauseSandboxInstanceResp>}
+     */
+    async pauseSandboxInstance(options) {
+        const { instanceId } = options;
+        // InstanceId 校验：必填
+        if (typeof instanceId !== 'string' || instanceId.trim().length === 0) {
+            throw new Error('instanceId is required');
+        }
+        const reqData = {
+            InstanceId: instanceId
+        };
+        return this.agsService.request('PauseSandboxInstance', reqData);
+    }
+    /**
+     * 更新沙箱实例
+     * 更新指定沙箱实例的超时时间和元数据等信息。
+     * @param {UpdateSandboxInstanceOptions} options 更新参数
+     * @returns {Promise<UpdateSandboxInstanceResp>}
+     */
+    async updateSandboxInstance(options) {
+        const { instanceId, timeout, metadata } = options;
+        // InstanceId 校验：必填
+        if (typeof instanceId !== 'string' || instanceId.trim().length === 0) {
+            throw new Error('instanceId is required');
+        }
+        // Timeout 校验：格式如 30s、5m、1h，最小 30s，最大 24h
+        if (timeout !== undefined) {
+            if (typeof timeout !== 'string' || !/^\d+[smh]$/.test(timeout)) {
+                throw new Error('timeout must match format like 30s, 5m, 1h');
+            }
+        }
+        // Metadata 校验
+        if (metadata !== undefined) {
+            if (!Array.isArray(metadata)) {
+                throw new Error('metadata must be an array');
+            }
+        }
+        // 构造请求体
+        const reqData = {
+            InstanceId: instanceId
+        };
+        if (timeout !== undefined) {
+            reqData.Timeout = timeout;
+        }
+        if (metadata !== undefined) {
+            reqData.Metadata = metadata;
+        }
+        return this.agsService.request('UpdateSandboxInstance', reqData);
+    }
+    /**
+     * 停止沙箱实例
+     * @param {StopSandboxInstanceOptions} options 停止参数
+     * @returns {Promise<StopSandboxInstanceResp>}
+     */
+    async stopSandboxInstance(options) {
+        const { instanceId } = options;
+        // InstanceId 校验：必填
+        if (typeof instanceId !== 'string' || instanceId.trim().length === 0) {
+            throw new Error('instanceId is required');
+        }
+        const reqData = {
+            InstanceId: instanceId
+        };
+        return this.agsService.request('StopSandboxInstance', reqData);
+    }
+    /**
+     * 启动沙箱实例
+     * @param {StartSandboxInstanceOptions} options 启动参数
+     * @returns {Promise<StartSandboxInstanceResp>}
+     */
+    async startSandboxInstance(options) {
+        const { toolId, toolName, timeout, clientToken, mountOptions, customConfiguration, authMode, metadata } = options;
+        // ToolId 与 ToolName 至少有一个要填
+        const hasToolId = toolId !== undefined && toolId.trim().length > 0;
+        const hasToolName = toolName !== undefined && toolName.trim().length > 0;
+        if (!hasToolId && !hasToolName) {
+            throw new Error('toolId or toolName is required, at least one must be provided');
+        }
+        // Timeout 校验：格式如 30s、5m、1h
+        if (timeout !== undefined) {
+            if (typeof timeout !== 'string' || !/^\d+[smh]$/.test(timeout)) {
+                throw new Error('timeout must match format like 30s, 5m, 1h');
+            }
+        }
+        // ClientToken 校验：最大 64 字符
+        if (clientToken !== undefined && clientToken.length > 64) {
+            throw new Error('clientToken length must be <= 64');
+        }
+        // MountOptions 校验
+        if (mountOptions !== undefined) {
+            if (!Array.isArray(mountOptions)) {
+                throw new Error('mountOptions must be an array');
+            }
+        }
+        // AuthMode 校验
+        if (authMode !== undefined) {
+            const validAuthModes = ['DEFAULT', 'TOKEN', 'NONE'];
+            if (!validAuthModes.includes(authMode)) {
+                throw new Error(`authMode must be one of: ${validAuthModes.join(', ')}`);
+            }
+        }
+        // CustomConfiguration 校验
+        if (customConfiguration !== undefined) {
+            if (customConfiguration.Image !== undefined) {
+                if (typeof customConfiguration.Image !== 'string' || customConfiguration.Image.trim().length === 0) {
+                    throw new Error('Image must be a non-empty string');
+                }
+            }
+            if (customConfiguration.ImageRegistryType !== undefined) {
+                const validTypes = ['enterprise', 'personal'];
+                if (!validTypes.includes(customConfiguration.ImageRegistryType)) {
+                    throw new Error(`ImageRegistryType must be one of: ${validTypes.join(', ')}`);
+                }
+            }
+            if (customConfiguration.DNSConfig !== undefined) {
+                if (!Array.isArray(customConfiguration.DNSConfig.Servers) || customConfiguration.DNSConfig.Servers.length === 0) {
+                    throw new Error('DNSConfig.Servers is required and must be a non-empty array');
+                }
+            }
+        }
+        // Metadata 校验
+        if (metadata !== undefined) {
+            if (!Array.isArray(metadata)) {
+                throw new Error('metadata must be an array');
+            }
+        }
+        // 构造请求体
+        const reqData = {};
+        if (toolId !== undefined) {
+            reqData.ToolId = toolId;
+        }
+        if (toolName !== undefined) {
+            reqData.ToolName = toolName;
+        }
+        if (timeout !== undefined) {
+            reqData.Timeout = timeout;
+        }
+        if (clientToken !== undefined) {
+            reqData.ClientToken = clientToken;
+        }
+        if (mountOptions !== undefined) {
+            reqData.MountOptions = mountOptions;
+        }
+        if (customConfiguration !== undefined) {
+            reqData.CustomConfiguration = customConfiguration;
+        }
+        if (authMode !== undefined) {
+            reqData.AuthMode = authMode;
+        }
+        if (metadata !== undefined) {
+            reqData.Metadata = metadata;
+        }
+        return this.agsService.request('StartSandboxInstance', reqData);
+    }
+    /**
+     * 查询沙箱实例列表
+     * @param {DescribeSandboxInstanceListOptions} options 查询参数
+     * @returns {Promise<DescribeSandboxInstanceListResp>}
+     */
+    async describeSandboxInstanceList(options = {}) {
+        const { instanceIds, toolId, offset, limit, filters } = options;
+        // InstanceIds 校验
+        if (instanceIds !== undefined) {
+            if (!Array.isArray(instanceIds)) {
+                throw new Error('instanceIds must be an array');
+            }
+            if (instanceIds.length > 100) {
+                throw new Error('instanceIds length must be <= 100');
+            }
+            const invalidId = instanceIds.find(id => typeof id !== 'string' || id.trim().length === 0);
+            if (invalidId !== undefined) {
+                throw new Error('instanceIds contains invalid item');
+            }
+        }
+        // ToolId 校验
+        if (toolId !== undefined) {
+            if (typeof toolId !== 'string' || toolId.trim().length === 0) {
+                throw new Error('toolId must be a non-empty string');
+            }
+        }
+        // Offset 校验
+        if (offset !== undefined && (!Number.isInteger(offset) || offset < 0)) {
+            throw new Error('offset must be a non-negative integer');
+        }
+        // Limit 校验
+        if (limit !== undefined && (!Number.isInteger(limit) || limit < 1 || limit > 100)) {
+            throw new Error('limit must be an integer between 1 and 100');
+        }
+        // Filters 校验
+        if (filters !== undefined) {
+            if (!Array.isArray(filters)) {
+                throw new Error('filters must be an array');
+            }
+        }
+        // 构造请求体
+        const reqData = {};
+        if (instanceIds !== undefined && instanceIds.length > 0) {
+            reqData.InstanceIds = instanceIds;
+        }
+        if (toolId !== undefined) {
+            reqData.ToolId = toolId;
+        }
+        if (offset !== undefined) {
+            reqData.Offset = offset;
+        }
+        if (limit !== undefined) {
+            reqData.Limit = limit;
+        }
+        if (filters !== undefined && filters.length > 0) {
+            reqData.Filters = filters;
+        }
+        return this.agsService.request('DescribeSandboxInstanceList', reqData);
+    }
+    /**
+     * 获取沙箱实例访问 Token
+     * 获取访问沙箱工具时所需要使用的访问 Token，创建沙箱实例后需调用此接口获取沙箱实例访问 Token。
+     * 此 Token 可用于调用代码沙箱实例执行代码，或浏览器沙箱实例进行浏览器操作等。
+     * @param {AcquireSandboxInstanceTokenOptions} options 请求参数
+     * @returns {Promise<AcquireSandboxInstanceTokenResp>}
+     */
+    async acquireSandboxInstanceToken(options) {
+        const { instanceId } = options;
+        // InstanceId 校验：必填
+        if (typeof instanceId !== 'string' || instanceId.trim().length === 0) {
+            throw new Error('instanceId is required');
+        }
+        const reqData = {
+            InstanceId: instanceId
+        };
+        return this.agsService.request('AcquireSandboxInstanceToken', reqData);
+    }
+    /**
+     * 获取 API 密钥列表
+     * 获取 API 密钥简略信息列表，包含名称、创建时间等。
+     * @returns {Promise<DescribeAPIKeyListResp>}
+     */
+    async describeAPIKeyList() {
+        return this.agsService.request('DescribeAPIKeyList', {});
+    }
+    /**
+     * 创建 API 密钥
+     * 创建新的 API 密钥，用于调用 Agent Sandbox 接口。
+     * 注意：生成的 APIKey 仅在此次响应中返回，后续无法再次获取，请妥善保管。
+     * @param {CreateAPIKeyOptions} options 创建参数
+     * @returns {Promise<CreateAPIKeyResp>}
+     */
+    async createAPIKey(options = {}) {
+        const { name } = options;
+        // Name 校验
+        if (name !== undefined) {
+            if (typeof name !== 'string' || name.trim().length === 0) {
+                throw new Error('name must be a non-empty string');
+            }
+        }
+        // 构造请求体
+        const reqData = {};
+        if (name !== undefined) {
+            reqData.Name = name;
+        }
+        return this.agsService.request('CreateAPIKey', reqData);
+    }
+    /**
+     * 删除 API 密钥
+     * 注意：本接口删除的是 Agent Sandbox 专用 API Key，区别于腾讯云 Secret ID / Secret Key。
+     * @param {DeleteAPIKeyOptions} options 删除参数
+     * @returns {Promise<DeleteAPIKeyResp>}
+     */
+    async deleteAPIKey(options) {
+        const { keyId } = options;
+        // KeyId 校验：必填
+        if (typeof keyId !== 'string' || keyId.trim().length === 0) {
+            throw new Error('keyId is required');
+        }
+        const reqData = {
+            KeyId: keyId
+        };
+        return this.agsService.request('DeleteAPIKey', reqData);
+    }
+}
+exports.SandboxService = SandboxService;

package/lib/sandbox/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cloudbase/manager-node",
-    "version": "5.1.1",
+    "version": "5.2.0-beta.1",
     "description": "The node manage service api for cloudbase.",
     "main": "lib/index.js",
     "scripts": {

package/types/environment.d.ts

@@ -16,6 +16,7 @@ import { MysqlService } from './mysql';
 import { CloudAppService } from './cloudApp';
 import { EnvInfo } from './interfaces';
 import { PermissionService } from './permission';
+import { SandboxService } from './sandbox';
 export declare class Environment {
     inited: boolean;
     cloudBaseContext: CloudBaseContext;
@@ -37,6 +38,7 @@ export declare class Environment {
     private mysqlService;
     private permissionService;
     private cloudAppService;
+    private sandboxService;
     constructor(context: CloudBaseContext, envId: string);
     lazyInit(): Promise<any>;
     getEnvId(): string;
@@ -56,6 +58,7 @@ export declare class Environment {
     getMysqlService(): MysqlService;
     getCloudAppService(): CloudAppService;
     getPermissionService(): PermissionService;
+    getSandboxService(): SandboxService;
     getCommonService(serviceType: string, serviceVersion: any): CommonService;
     getServicesEnvInfo(): Promise<any>;
     getAuthConfig(): {

package/types/index.d.ts

@@ -16,6 +16,7 @@ import { CloudBaseRunService } from './cloudBaseRun';
 import { MysqlService } from './mysql';
 import { DocsService } from './docs';
 import { PermissionService } from './permission';
+import { SandboxService } from './sandbox';
 import { CloudAppService } from './cloudApp';
 interface CloudBaseConfig {
     secretId?: string;
@@ -80,6 +81,7 @@ declare class CloudBase {
     get third(): ThirdService;
     get user(): UserService;
     get permission(): PermissionService;
+    get sandbox(): SandboxService;
     get docs(): DocsService;
     getEnvironmentManager(): EnvironmentManager;
     getManagerConfig(): CloudBaseConfig;