@cloudbase/cli 1.11.0 → 1.12.2-alpha.1

package/types/types.d.ts

@@ -0,0 +1,460 @@
+/// <reference types="node" />
+export declare type CustomEvent = 'logout';
+export interface ICommandContext {
+    cmd: string;
+    envId: string;
+    config: ICloudBaseConfig;
+    options: any;
+    params: string[];
+}
+declare global {
+    namespace NodeJS {
+        interface Process extends EventEmitter {
+            VERBOSE: boolean;
+            CLI_VERSION: string;
+            on(event: CustomEvent, listener: BeforeExitListener): any;
+            emit(event: CustomEvent, message?: any): any;
+        }
+    }
+}
+export interface PermanentCredential {
+    secretId?: string;
+    secretKey?: string;
+}
+export interface TmpCredential {
+    tmpSecretId?: string;
+    tmpSecretKey?: string;
+    tmpToken?: string;
+    tmpExpired?: string;
+    expired?: string;
+    authTime?: string;
+    refreshToken?: string;
+    uin?: string;
+    hash?: string;
+}
+export declare type Credential = TmpCredential & PermanentCredential;
+export interface AuthSecret {
+    secretId: string;
+    secretKey: string;
+    token?: string;
+}
+export interface IConfig {
+    credential?: Credential;
+}
+export interface ICloudBaseConfig {
+    envId: string;
+    functionRoot?: string;
+    functions?: ICloudFunction[];
+    servers?: ServerConfig[];
+}
+export interface IGetCredential {
+    secretId?: string;
+    secretKey?: string;
+    token: string;
+}
+export declare enum ServerLanguageType {
+    node = "node"
+}
+export interface ServerConfig {
+    type: ServerLanguageType.node;
+    name: string;
+    path: string;
+}
+export interface IFunctionPackResult {
+    success: boolean;
+    assets: string[];
+    vemo?: boolean;
+}
+export interface IFunctionVPC {
+    subnetId: string;
+    vpcId: string;
+}
+export interface ICloudFunctionConfig {
+    timeout?: number;
+    envVariables?: Record<string, string | number | boolean>;
+    runtime?: string;
+    vpc?: IFunctionVPC;
+    installDependency?: boolean;
+    l5?: boolean;
+}
+export interface ICloudFunctionTrigger {
+    name: string;
+    type: string;
+    config: string;
+}
+export interface ICloudFunction {
+    name: string;
+    config?: ICloudFunctionConfig;
+    triggers?: ICloudFunctionTrigger[];
+    params?: Record<string, string>;
+    handler?: string;
+    ignore?: string | string[];
+    timeout?: number;
+    envVariables?: Record<string, string | number | boolean>;
+    runtime?: string;
+    vpc?: IFunctionVPC;
+    l5?: boolean;
+    installDependency?: boolean;
+    isWaitInstall?: boolean;
+}
+export interface ICreateFunctionOptions {
+    func?: ICloudFunction;
+    functions?: ICloudFunction[];
+    functionRootPath?: string;
+    envId: string;
+    force?: boolean;
+    base64Code?: string;
+    log?: boolean;
+    codeSecret?: string;
+    functionPath?: string;
+    accessPath?: string;
+}
+export interface IListFunctionOptions {
+    limit?: number;
+    offset?: number;
+    envId: string;
+}
+export interface IFunctionLogOptions {
+    functionName: string;
+    envId: string;
+    offset?: number;
+    limit?: number;
+    order?: string;
+    orderBy?: string;
+    startTime?: string;
+    endTime?: string;
+    functionRequestI?: string;
+}
+export interface IUpdateFunctionConfigOptions {
+    functionName: string;
+    config: ICloudFunctionConfig;
+    envId: string;
+}
+export interface InvokeFunctionOptions {
+    functionName: string;
+    params?: Record<string, any>;
+    envId: string;
+}
+export interface IFunctionBatchOptions {
+    functions: ICloudFunction[];
+    envId: string;
+    log?: boolean;
+}
+export interface IFunctionTriggerOptions {
+    functionName: string;
+    triggers?: ICloudFunctionTrigger[];
+    triggerName?: string;
+    envId: string;
+}
+export interface ILoginOptions {
+    key?: boolean;
+    secretId?: string;
+    secretKey?: string;
+    token?: string;
+    getAuthUrl?: (url: string) => string;
+}
+export interface GatewayContext {
+    envId: string;
+    config: ICloudBaseConfig;
+}
+export interface ICreateFunctionGatewayOptions {
+    envId: string;
+    path: string;
+    name: string;
+}
+export interface IQueryGatewayOptions {
+    envId: string;
+    domain?: string;
+    path?: string;
+    gatewayId?: string;
+    name?: string;
+}
+export interface IDeleteGatewayOptions {
+    envId: string;
+    path?: string;
+    gatewayId?: string;
+    name?: string;
+}
+export interface IBindGatewayDomainOptions {
+    envId: string;
+    domain: string;
+}
+export interface IQueryGatewayDomainOptions {
+    envId: string;
+    domain?: string;
+}
+export interface IUnbindGatewayDomainOptions {
+    envId: string;
+    domain: string;
+}
+export interface IListRunOptions {
+    limit?: number;
+    offset?: number;
+    envId: string;
+}
+export interface ICreateRunOptions {
+    envId: string;
+    name: string;
+    remark: string;
+    vpcInfo: {
+        VpcId: string;
+        SubnetIds: string[];
+        CreateType: number;
+    };
+    imageRepo?: string;
+    logType: string;
+    esInfo?: {
+        Ip: string;
+        Port: number;
+        Index: string;
+        Account: string;
+        Password: string;
+    };
+    isPublic: boolean;
+    publicAccess: number;
+}
+export interface IListVersionOptions {
+    envId: string;
+    limit?: number;
+    offset?: number;
+    serverName: string;
+}
+export interface IDeleteVersion {
+    envId: string;
+    serverName: string;
+    versionName: string;
+}
+export interface IModifyVersion {
+    envId: string;
+    serverName: string;
+    trafficType: string;
+    versionFlowItems: {
+        VersionName: string;
+        FlowRatio: number;
+        IsDefaultPriority?: boolean;
+        Priority?: number;
+        UrlParam?: {
+            Key: string;
+            Value: string;
+        };
+    }[];
+}
+export interface IBuildImage {
+    envId: string;
+    serviceName: string;
+}
+export interface ICreateVersion {
+    envId: string;
+    serverName: string;
+    containerPort: number;
+    uploadType: string;
+    packageName?: string;
+    packageVersion?: string;
+    repositoryType?: string;
+    branch?: string;
+    codeDetail?: {
+        Name: {
+            Name: string;
+            FullName: string;
+        };
+    };
+    imageInfo?: {
+        ImageUrl: string;
+    };
+    flowRatio: number;
+    versionRemark: string;
+    enableUnion: true;
+    cpu: number;
+    mem: number;
+    minNum: number;
+    maxNum: number;
+    policyType: string;
+    policyThreshold: number;
+    customLogs: string;
+    dockerfilePath?: string;
+    envParams: string;
+    initialDelaySeconds: number;
+}
+export interface IUpdateVersion {
+    envId: string;
+    serverName: string;
+    versionName: string;
+    containerPort: number;
+    uploadType: string;
+    packageName?: string;
+    packageVersion?: string;
+    repositoryType?: string;
+    branch?: string;
+    codeDetail?: {
+        Name: {
+            Name: string;
+            FullName: string;
+        };
+    };
+    imageInfo?: {
+        ImageUrl: string;
+    };
+    flowRatio: number;
+    versionRemark: string;
+    enableUnion: true;
+    cpu: number;
+    mem: number;
+    minNum: number;
+    maxNum: number;
+    policyType: string;
+    policyThreshold: number;
+    customLogs: string;
+    dockerfilePath?: string;
+    envParams: string;
+    initialDelaySeconds: number;
+}
+export interface IListCodeRepo {
+    channel: string;
+    pageNumber: number;
+    pageSize: number;
+}
+export interface IListBranch {
+    channel: string;
+    pageNumber: number;
+    pageSize: number;
+    repoName: {
+        Name: string;
+        FullName: string;
+    };
+}
+export interface IListImage {
+    envId: string;
+    serviceName: string;
+    limit: number;
+    offset: number;
+}
+export interface IDeleteImage {
+    envId: string;
+    imageUrl: string;
+}
+export interface ILogCreateVersion {
+    envId: string;
+    runId: string;
+}
+export interface IDescribeRunVersion {
+    envId: string;
+    serverName: string;
+    versionName: string;
+}
+export interface IDeleteRun {
+    envId: string;
+    serverName: string;
+}
+export interface IListPackageStandaloneGateway {
+    envId: string;
+    packageVersion: string;
+}
+export interface ICreateStandaloneGateway {
+    envId: string;
+    gatewayAlias: string;
+    gatewayDesc: string;
+    vpcId: string;
+    subnetIds: string[];
+    packageVersion: string;
+}
+export interface IListStandaloneGateway {
+    envId: string;
+    gatewayName: string;
+    gatewayAlias: string;
+}
+export interface ITurnOnStandaloneGateway {
+    envId: string;
+    gatewayName: string;
+    serviceList: string[];
+}
+export interface ITurnOffStandaloneGateway {
+    envId: string;
+    gatewayName: string;
+    serviceList: string[];
+}
+export interface IDestroyStandaloneGateway {
+    envId: string;
+    gatewayName: string;
+}
+export interface IPublishVersionParams {
+    envId: string;
+    functionName: string;
+    description?: string;
+}
+export interface IListFunctionVersionParams {
+    envId: string;
+    functionName: string;
+    offset?: number;
+    limit?: number;
+    order?: string;
+    orderBy?: string;
+}
+export interface IFunctionVersion {
+    Version: string;
+    Description: string;
+    AddTime: string;
+    ModTime: string;
+    Status: string;
+}
+export interface IFunctionVersionsRes {
+    FunctionVersion: string[];
+    Versions: IFunctionVersion[];
+    TotalCount: number;
+}
+export interface ISetProvisionedConcurrencyConfig {
+    envId: string;
+    functionName: string;
+    qualifier: string;
+    versionProvisionedConcurrencyNum: number;
+}
+export interface IGetProvisionedConcurrencyConfig {
+    functionName: string;
+    qualifier?: string;
+    envId: string;
+}
+export interface IGetProvisionedConcurrencyRes {
+    UnallocatedConcurrencyNum: number;
+    Allocated: IVersionProvisionedConcurrencyInfo[];
+}
+export interface IVersionProvisionedConcurrencyInfo {
+    AllocatedProvisionedConcurrencyNum: number;
+    AvailableProvisionedConcurrencyNum: number;
+    Status: string;
+    StatusReason: string;
+    Qualifier: string;
+}
+export interface IUpdateFunctionAliasConfig {
+    envId: string;
+    functionName: string;
+    name: string;
+    functionVersion: string;
+    description?: string;
+    routingConfig?: IRoutingConfig;
+}
+export interface IRoutingConfig {
+    AdditionalVersionWeights?: IVersionWeight[];
+    AddtionVersionMatchs?: IVersionMatch[];
+}
+export interface IVersionMatch {
+    Version: string;
+    Key: string;
+    Method: string;
+    Expression: string;
+}
+export interface IVersionWeight {
+    Version: string;
+    Weight: number;
+}
+export interface IGetFunctionAlias {
+    envId: string;
+    functionName: string;
+    name: string;
+}
+export interface IGetFunctionAliasRes {
+    FunctionVersion: string;
+    Name: string;
+    RoutingConfig: IRoutingConfig;
+    Description: string;
+    AddTime: string;
+    ModTime: string;
+}

package/types/utils/auth.d.ts

@@ -0,0 +1,3 @@
+import { AuthSupevisor } from '@cloudbase/toolbox';
+export declare const authSupevisor: AuthSupevisor;
+export declare function getLoginState(): Promise<import("@cloudbase/toolbox").Credential>;

package/types/utils/cli-table.d.ts

@@ -0,0 +1,2 @@
+import { TableOptions } from 'cli-table3';
+export declare function printHorizontalTable(head: string[], data?: (string | number)[][], options?: TableOptions): void;

package/types/utils/config.d.ts

@@ -0,0 +1,11 @@
+import { Arguments } from 'yargs';
+import { ICloudBaseConfig } from '@cloudbase/toolbox';
+export interface IArgs {
+    envId: string;
+    region: string;
+    verbose: boolean;
+    configPath: string;
+    [x: string]: unknown;
+}
+export declare const getArgs: () => Arguments<IArgs>;
+export declare const getCloudBaseConfig: (configPath?: string) => Promise<ICloudBaseConfig>;

package/types/utils/env.d.ts

@@ -0,0 +1,5 @@
+export declare function getSelectedEnv(inputEnvId?: string): Promise<any>;
+export declare function getSelectRegion(): Promise<any>;
+export declare function checkTcbService(): Promise<boolean>;
+export declare function checkEnvStatus(envId: string): Promise<void>;
+export declare function checkEnvAvaliable(envId: string): Promise<void>;

package/types/utils/fs/del.d.ts

@@ -0,0 +1 @@
+export declare function delSync(patterns: string | readonly string[]): void;

package/types/utils/fs/index.d.ts

@@ -0,0 +1,7 @@
+export * from './del';
+export declare type SizeUnit = 'KB' | 'MB' | 'GB';
+export declare function checkFullAccess(dest: string, throwError?: boolean): boolean;
+export declare function checkWritable(dest: string, throwError?: boolean): boolean;
+export declare function checkReadable(dest: string, throwError?: boolean): boolean;
+export declare function isDirectory(dest: string): boolean;
+export declare function formateFileSize(size: number | string, unit: SizeUnit): string;

package/types/utils/function-packer.d.ts

@@ -0,0 +1,18 @@
+export declare enum CodeType {
+    File = 0,
+    JavaFile = 1
+}
+export declare class FunctionPacker {
+    root: string;
+    name: string;
+    type: CodeType;
+    funcPath: string;
+    funcDistPath: string;
+    tmpPath: string;
+    ignore: string | string[];
+    constructor(root: string, name: string, ignore: string | string[]);
+    getFileCode(): Promise<string>;
+    getJavaFileCode(): string;
+    build(type: CodeType): Promise<string>;
+    clean(): void;
+}

package/types/utils/index.d.ts

@@ -0,0 +1,18 @@
+export * from './net';
+export * from './fs';
+export * from './tools';
+export * from './output';
+export * from './platform';
+export * from './reporter';
+export * from './cli-table';
+export * from './progress-bar';
+export * from './function-packer';
+export * from './prompt';
+export * from './env';
+export * from './log';
+export * from './template';
+export * from './config';
+export * from './auth';
+export * from './store';
+export * from './notice';
+export * from './parallel';

package/types/utils/log.d.ts

@@ -0,0 +1,21 @@
+export declare class Logger {
+    c: {
+        _times: Map<any, any>;
+        log(a: string, ...args: string[]): void;
+    };
+    verboseEnabled: boolean;
+    constructor(options?: {
+        verbose?: boolean;
+    });
+    breakLine(): void;
+    log(...args: any[]): void;
+    info(msg: string): void;
+    success(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+    verbose(...args: any): void;
+    genClickableLink(link: string): string;
+    printClickableLink(link: string): void;
+    time(label: string, fn: Promise<any> | (() => Promise<any>)): Promise<any>;
+}
+export declare const logger: Logger;

package/types/utils/net/cloud-api-request.d.ts

@@ -0,0 +1,9 @@
+import { CloudApiService as _CloudApiService } from '@cloudbase/cloud-api';
+export declare class CloudApiService {
+    static serviceCacheMap: Record<string, CloudApiService>;
+    static getInstance(service: string): CloudApiService;
+    region: string;
+    apiService: _CloudApiService;
+    constructor(service: string, baseParams?: Record<string, any>, version?: string);
+    request(action: string, data?: Record<string, any>, method?: 'POST' | 'GET'): Promise<any>;
+}

package/types/utils/net/credential.d.ts

@@ -0,0 +1,5 @@
+import { Credential, AuthSecret } from '../../types';
+export declare function refreshTmpToken(metaData: Credential & {
+    isLogout?: boolean;
+}): Promise<Credential>;
+export declare function checkAndGetCredential(throwError?: boolean): Promise<AuthSecret>;

package/types/utils/net/http-request.d.ts

@@ -0,0 +1,4 @@
+import { RequestInit } from 'node-fetch';
+export declare function fetch(url: string, config?: RequestInit): Promise<any>;
+export declare function postFetch(url: string, data?: Record<string, any>): Promise<any>;
+export declare function fetchStream(url: any, config?: Record<string, any>): Promise<import("node-fetch").Response>;

package/types/utils/net/index.d.ts

@@ -0,0 +1,5 @@
+export * from './proxy';
+export * from './credential';
+export * from './http-request';
+export * from './manager-service';
+export * from './cloud-api-request';

package/types/utils/net/manager-service.d.ts

@@ -0,0 +1,4 @@
+import CloudBase from '@cloudbase/manager-node';
+import { StorageService } from '@cloudbase/manager-node/types/storage';
+export declare function getMangerService(envId?: string): Promise<CloudBase>;
+export declare function getStorageService(envId: string): Promise<StorageService>;

package/types/utils/net/proxy.d.ts

@@ -0,0 +1 @@
+export declare function getProxy(): string;

package/types/utils/notice.d.ts

@@ -0,0 +1 @@
+export declare function getNotification(): Promise<any>;

package/types/utils/output/highlight.d.ts

@@ -0,0 +1 @@
+export declare function highlightCommand(command: string): string;

package/types/utils/output/index.d.ts

@@ -0,0 +1,3 @@
+export * from './loading';
+export * from './link';
+export * from './highlight';

package/types/utils/output/link.d.ts

@@ -0,0 +1 @@
+export declare function genClickableLink(link: string): string;

package/types/utils/output/loading.d.ts

@@ -0,0 +1,18 @@
+declare class Loading {
+    private spinner;
+    constructor();
+    set text(text: string);
+    start(text: string): void;
+    stop(): void;
+    succeed(text: string): void;
+    fail(text: string): void;
+}
+export declare const loadingFactory: () => Loading;
+declare type Task<T> = (flush: (text: string) => void, ...args: any[]) => Promise<T>;
+export interface ILoadingOptions {
+    startTip?: string;
+    successTip?: string;
+    failTip?: string;
+}
+export declare const execWithLoading: <T>(task: Task<T>, options?: ILoadingOptions) => Promise<T>;
+export {};

package/types/utils/parallel.d.ts

@@ -0,0 +1,11 @@
+export declare type AsyncTask = () => Promise<any>;
+export declare class AsyncTaskParallelController {
+    maxParallel: number;
+    tasks: AsyncTask[];
+    checkInterval: number;
+    totalTasks: number;
+    constructor(maxParallel: number, checkInterval?: number);
+    loadTasks(tasks: AsyncTask[]): void;
+    push(task: AsyncTask): void;
+    run(): Promise<any[]>;
+}

package/types/utils/platform/index.d.ts

@@ -0,0 +1,3 @@
+export * from './os';
+export * from './mac';
+export * from './port';

package/types/utils/platform/mac.d.ts

@@ -0,0 +1,2 @@
+export declare function getMacAddress(): Promise<string>;
+export declare function getMacAddressMd5(): Promise<string>;

package/types/utils/platform/os.d.ts

@@ -0,0 +1,2 @@
+export declare function getPlatformRelease(platform: string, release: string): string;
+export declare function getOSInfo(): string;

package/types/utils/platform/port.d.ts

@@ -0,0 +1 @@
+export declare function getPort(): Promise<number>;

package/types/utils/progress-bar.d.ts

@@ -0,0 +1 @@
+export declare function createUploadProgressBar(onFinished: Function, onStart?: Function): (data: any) => void;

package/types/utils/prompt/index.d.ts

@@ -0,0 +1 @@
+export * from './select';

package/types/utils/prompt/select.d.ts

@@ -0,0 +1,4 @@
+export declare const pagingSelectPromp: <T, O extends {
+    limit?: number;
+    offset?: number;
+}>(type: 'select' | 'multiselect', listFetcher: (options: O) => Promise<any[]>, options: O, message: string, filter?: (item: any) => boolean, mapper?: (item: any) => string) => Promise<string | string[]>;

package/types/utils/reporter/agree.d.ts

@@ -0,0 +1 @@
+export declare function collectAgree(agree: any): Promise<any>;

package/types/utils/reporter/download.d.ts

@@ -0,0 +1 @@
+export declare function templateDownloadReport(templateId: string, templateName: string): Promise<void>;

package/types/utils/reporter/index.d.ts

@@ -0,0 +1,3 @@
+export * from './agree';
+export * from './usage';
+export * from './download';

package/types/utils/reporter/usage.d.ts

@@ -0,0 +1 @@
+export declare function collectUsage(command: string): Promise<any>;