@cloudbase/cli 2.0.12 → 2.1.0

package/src/commands/account/login.ts

@@ -1,192 +0,0 @@
-import _ from 'lodash'
-import chalk from 'chalk'
-import inquirer from 'inquirer'
-import { Command, ICommand } from '../common'
-import { login } from '../../auth'
-import { listEnvs } from '../../env'
-import { CloudBaseError } from '../../error'
-import { InjectParams, ArgsOptions, Log, Logger } from '../../decorators'
-import {
-    loadingFactory,
-    usageStore,
-    collectAgree,
-    genClickableLink,
-    checkAndGetCredential
-} from '../../utils'
-
-function printSuggestion() {
-    const tips = `可使用下面命令继续操作：
-
-${chalk.gray('–')} 创建免费环境
-
-  ${chalk.cyan('$ tcb env create envName')}
-
-${chalk.gray('–')} 初始化云开发项目
-
-  ${chalk.cyan('$ tcb new')}
-
-${chalk.gray('–')} 部署云函数
-
-  ${chalk.cyan('$ tcb fn deploy')}
-
-${chalk.gray('–')} 查看命令使用介绍
-
-  ${chalk.cyan('$ tcb -h')}
-
-Tips：可以使用简写命令 tcb 代替 cloudbase`
-    console.log(tips)
-}
-
-async function askForCollectDataConfirm() {
-    const agree = await usageStore.get('agreeCollect')
-    if (agree) return
-    // 询问
-    const { confirm } = await inquirer.prompt({
-        type: 'confirm',
-        name: 'confirm',
-        message: '是否同意 Cloudbase CLI 收集您的使用数据以改进产品？',
-        default: true
-    })
-
-    if (confirm) {
-        await usageStore.set('agreeCollect', true)
-    }
-
-    await collectAgree(confirm)
-}
-
-@ICommand()
-export class LoginCommand extends Command {
-    get options() {
-        return {
-            cmd: 'login',
-            options: [
-                {
-                    flags: '-k, --key',
-                    desc: '使用永久密钥登录'
-                },
-                {
-                    flags: '--apiKeyId <apiKeyId>',
-                    desc: '腾讯云 API 秘钥 Id'
-                },
-                {
-                    flags: '--apiKey <apiKey>',
-                    desc: '腾讯云 API 秘钥 Key'
-                },
-                {
-                    flags: '--token [token]',
-                    desc: '腾讯云 API 临时秘钥 Token'
-                }
-            ],
-            desc: '登录腾讯云账号',
-            requiredEnvId: false,
-            withoutAuth: true
-        }
-    }
-
-    @InjectParams()
-    async execute(@ArgsOptions() options, @Log() log: Logger) {
-        log.verbose(options)
-        const { apiKeyId, apiKey, token } = options
-        const loading = loadingFactory()
-        loading.start('检验登录状态')
-
-        const credential = await checkAndGetCredential()
-
-        if (!_.isEmpty(credential)) {
-            loading.succeed('您已登录，无需再次登录！')
-            return
-        } else {
-            loading.stop()
-        }
-
-        // 通过参数传入 API Key，适用于 CI 场景
-        if (apiKey && apiKeyId) {
-            loading.start('正在验证腾讯云密钥...')
-
-            const res = await login({
-                token,
-                key: true,
-                secretKey: apiKey,
-                secretId: apiKeyId
-            })
-
-            if (res.code === 'SUCCESS') {
-                loading.succeed('登录成功！')
-                printSuggestion()
-            } else {
-                loading.fail('腾讯云密钥验证失败，请检查密钥是否正确或终端网络是否可用！')
-                return process.exit(1)
-            }
-        } else if (options.key) {
-            // 兼容临时密钥和永久密钥登录
-            const clickableLink = genClickableLink('https://console.cloud.tencent.com/cam/capi')
-            console.log(`您可以访问 ${clickableLink} 获取 API 秘钥`)
-
-            // 使用永久密钥登录
-            const { secretId } = await inquirer.prompt({
-                type: 'input',
-                name: 'secretId',
-                message: '请输入腾讯云 SecretID：'
-            })
-
-            const { secretKey } = await inquirer.prompt({
-                type: 'input',
-                name: 'secretKey',
-                message: '请输入腾讯云 SecretKey：'
-            })
-
-            if (!secretId || !secretKey) {
-                throw new CloudBaseError('SecretID 或 SecretKey 不能为空')
-            }
-
-            loading.start('正在验证腾讯云密钥...')
-
-            const res = await login({
-                key: true,
-                secretId,
-                secretKey
-            })
-
-            if (res.code === 'SUCCESS') {
-                loading.succeed('登录成功！')
-                await askForCollectDataConfirm()
-                printSuggestion()
-            } else {
-                loading.fail('腾讯云密钥验证失败，请检查密钥是否正确或终端网络是否可用！')
-                return process.exit(1)
-            }
-        } else {
-            // 使用临时密钥登录-支持自动续期
-            loading.start('获取授权中...')
-            const res = await login()
-
-            if (res.code === 'SUCCESS') {
-                loading.succeed('登录成功！')
-                await askForCollectDataConfirm()
-                printSuggestion()
-            } else {
-                loading.fail(res.msg)
-                console.log('Web 授权登录失败，秘钥校验失败！')
-                return process.exit(1)
-            }
-        }
-
-        // 检测用户是否存在，不存在则初始化
-        try {
-            const envs = await listEnvs()
-            if (!envs.length) {
-                log.warn('您还没有可用的环境，请使用 cloudbase env:create $name 创建环境')
-            }
-        } catch (e) {
-            // 用户不存在
-            // 主账户可以直接使用 env:create 完成初始化工作
-            if (e.code === 'ResourceNotFound.UserNotExists') {
-                log.error('您还没有可用的环境，请使用 cloudbase env:create $name 创建环境！')
-            } else {
-                console.error(e)
-                throw e
-            }
-        }
-    }
-}

package/src/commands/account/logout.ts

@@ -1,24 +0,0 @@
-import { ICommand, Command } from '../common'
-
-import { logout } from '../../auth'
-import { InjectParams, Log, Logger } from '../../decorators'
-
-@ICommand()
-export class LogoutCommand extends Command {
-    get options() {
-        return {
-            cmd: 'logout',
-            options: [],
-            desc: '登出腾讯云账号',
-            requiredEnvId: false,
-            withoutAuth: true
-        }
-    }
-
-    @InjectParams()
-    async execute(@Log() log: Logger) {
-        await logout()
-
-        log.success('注销登录成功！')
-    }
-}

package/src/commands/common.ts

@@ -1,246 +0,0 @@
-import chalk from 'chalk'
-import * as Sentry from '@sentry/node'
-import { EventEmitter } from 'events'
-import { program, Command as Commander, Option } from 'commander'
-import { CloudBaseError } from '../error'
-import { ICommandContext } from '../types'
-import {
-    usageStore,
-    collectUsage,
-    loadingFactory,
-    getNotification,
-    getCloudBaseConfig,
-    authSupevisor
-} from '../utils'
-
-interface ICommandOption {
-    flags: string
-    desc: string
-    hideHelp?: boolean
-}
-
-export interface ICommandOptions {
-    // 废弃的命令
-    deprecateCmd?: string
-    // 基础资源命令
-    cmd: string
-    // 嵌套子命令
-    childCmd?:
-        | string
-        | {
-              cmd: string
-              desc: string
-          }
-    childSubCmd?: string
-    // 命令选项
-    options: ICommandOption[]
-    // 命令描述
-    desc: string
-    // 使用命令时是否必须要传入 EnvId
-    requiredEnvId?: boolean
-    // 多数命令都需要登陆，不需要登陆的命令需要特别声明
-    withoutAuth?: boolean
-}
-
-type CommandConstructor = new () => Command
-
-const registrableCommands: CommandConstructor[] = []
-const cmdMap = new Map()
-
-// 装饰器收集命令
-export function ICommand(): ClassDecorator {
-    return (target: any) => {
-        registrableCommands.push(target)
-    }
-}
-
-// 注册命令
-export function registerCommands() {
-    registrableCommands.forEach((Command) => {
-        const command = new Command()
-        command.init()
-    })
-}
-
-// 命令基类
-export abstract class Command extends EventEmitter {
-    on(
-        event: 'preHandle' | 'afterHandle',
-        listener: (ctx: ICommandContext, args: any[]) => void
-    ): this
-
-    // eslint-disable-next-line
-    on(event: string, listener: (ctx: ICommandContext, args: any[]) => void): this {
-        super.on(event, listener)
-        return this
-    }
-
-    // 初始化命令
-    public init() {
-        const { cmd, childCmd, childSubCmd, deprecateCmd } = this.options
-
-        // 不能使用 new Commander 重复声明同一个命令，需要缓存 cmd 实例
-        let instance: Commander
-
-        // 子命令
-        if (cmdMap.has(cmd)) {
-            instance = cmdMap.get(cmd)
-        } else {
-            // 新命令或原有的旧命令格式
-            instance = program.command(cmd) as Commander
-            // @ts-expect-error 这里是用来自定义commander fallback 帮助信息
-            instance._helpDescription = '输出帮助信息'
-            instance.addHelpCommand('help [command]', '查看命令帮助信息')
-            cmdMap.set(cmd, instance)
-        }
-
-        if (childCmd) {
-            let cmdKey: string
-            let cmdName: string
-            let desc: string
-
-            if (typeof childCmd === 'string') {
-                cmdKey = `${cmd}-${childCmd}`
-                cmdName = childCmd
-            } else {
-                cmdKey = `${cmd}-${childCmd.cmd}`
-                cmdName = childCmd.cmd
-                desc = childCmd.desc
-            }
-
-            if (cmdMap.has(cmdKey)) {
-                instance = cmdMap.get(cmdKey)
-            } else {
-                instance = instance.command(cmdName) as Commander
-                // @ts-expect-error 这里是用来自定义commander fallback 帮助信息
-                instance._helpDescription = '查看命令帮助信息'
-                desc && instance.description(desc)
-                cmdMap.set(cmdKey, instance)
-            }
-
-            if (childSubCmd) {
-                instance = instance.command(childSubCmd) as Commander
-            }
-        }
-
-        this.createProgram(instance, false)
-
-        if (deprecateCmd) {
-            // 构建新的命令提示
-            const newCmd = [cmd, childCmd, childSubCmd]
-                .filter((_) => _)
-                .map((item) => {
-                    if (typeof item === 'string') return item
-                    return item.cmd
-                })
-                .join(' ')
-            this.createProgram(program.command(deprecateCmd) as Commander, true, newCmd)
-        }
-    }
-
-    private createProgram(instance: Commander, deprecate: boolean, newCmd?: string) {
-        const { cmd, desc, options, requiredEnvId = true, withoutAuth = false } = this.options
-        instance.storeOptionsAsProperties(false)
-        options.forEach((option) => {
-            
-            const { hideHelp } = option
-            if(hideHelp) {
-                instance.addOption(new Option(option.flags, option.desc).hideHelp())
-            } else {
-                instance.option(option.flags, option.desc)
-            }
-            
-        })
-
-        instance.description(desc)
-
-        // tcb <cmd> params options
-        instance.action(async (...args) => {
-            // 命令的参数
-            const params = args.slice(0, -1)
-            const cmdOptions = instance.opts()
-            const parentOptions = program.opts()
-
-            const config = await getCloudBaseConfig(parentOptions?.configFile)
-            const envId = cmdOptions?.envId || config?.envId
-
-            const loginState = await authSupevisor.getLoginState()
-
-            // 校验登陆态
-            if (!withoutAuth && !loginState) {
-                throw new CloudBaseError('无有效身份信息，请使用 cloudbase login 登录')
-            }
-
-            if (!envId && requiredEnvId) {
-                throw new CloudBaseError(
-                    '未识别到有效的环境 Id，请使用 cloudbaserc 配置文件进行操作或通过 -e 参数指定环境 Id'
-                )
-            }
-
-            const ctx: ICommandContext = {
-                cmd,
-                envId,
-                config,
-                params,
-                options: cmdOptions
-            }
-
-            // 处理前
-            this.emit('preHandle', ctx, args.slice(0, -1))
-            await this.preHandle()
-
-            // 废弃警告
-            if (deprecate) {
-                console.log(
-                    chalk.bold.yellowBright(
-                        '\n',
-                        `⚠️  此命令将被废弃，请使用新的命令 tcb ${newCmd} 代替`
-                    ),
-                    '\n'
-                )
-            }
-
-            // 命令处理
-            await this.execute(ctx)
-
-            this.emit('afterHandle', ctx, args)
-            // 上报数据
-            this.afterHandle(ctx)
-        })
-    }
-
-    private async preHandle() {
-        const loading = loadingFactory()
-        try {
-            loading.start('数据加载中...')
-            const res = await getNotification()
-            loading.stop()
-            if (!res) return
-            const { title, content } = res
-            console.log(chalk.bold.cyan(title))
-            console.log(content, '\n')
-        } catch (e) {
-            loading.stop()
-            Sentry.captureException(e)
-        }
-    }
-
-    private async afterHandle(ctx) {
-        try {
-            const { cmd } = ctx
-            const agree = await usageStore.get('agreeCollect')
-            // 不同意上报、不上报使用数据
-            if (!agree) return
-            await collectUsage(cmd)
-        } catch (e) {
-            // 上报错误
-            Sentry.captureException(e)
-        }
-    }
-
-    // 执行命令
-    abstract execute(...args: any[]): void
-
-    // 获取命令参数
-    abstract get options(): ICommandOptions
-}

package/src/commands/env/base.ts

@@ -1,90 +0,0 @@
-import { Command, ICommand } from '../common'
-import { CloudBaseError } from '../../error'
-import { listEnvs, updateEnvInfo } from '../../env'
-import { InjectParams, EnvId, ArgsParams, Log, Logger } from '../../decorators'
-import { printHorizontalTable, loadingFactory } from '../../utils'
-
-@ICommand()
-export class EnvListCommand extends Command {
-    get options() {
-        return {
-            cmd: 'env',
-            childCmd: 'list',
-            deprecateCmd: 'env:list',
-            options: [],
-            desc: '展示云开发环境信息',
-            requiredEnvId: false
-        }
-    }
-
-    @InjectParams()
-    async execute(@Log() log: Logger) {
-        const loading = loadingFactory()
-        loading.start('数据加载中...')
-        const data = await listEnvs()
-        loading.stop()
-        const head = ['名称', '环境 Id', '套餐版本', '来源', '创建时间', '环境状态']
-
-        const sortData = data.sort((prev, next) => {
-            if (prev.Alias > next.Alias) {
-                return 1
-            }
-            if (prev.Alias < next.Alias) {
-                return -1
-            }
-            return 0
-        })
-
-        const tableData = sortData.map((item) => [
-            item.Alias,
-            item.EnvId,
-            item.PackageName || '按量计费',
-            item.Source === 'miniapp' ? '小程序' : '云开发',
-            item.CreateTime,
-            item.Status === 'NORMAL' ? '正常' : '不可用'
-        ])
-
-        printHorizontalTable(head, tableData)
-        // 不可用环境警告
-        const unavailableEnv = data.find((item) => item.Status === 'UNAVAILABLE')
-        if (unavailableEnv) {
-            log.warn(`您的环境中存在不可用的环境：[${unavailableEnv.EnvId}]，请留意！`)
-        }
-    }
-}
-
-@ICommand()
-export class EnvRenameCommand extends Command {
-    get options() {
-        return {
-            cmd: 'env',
-            childCmd: 'rename <name>',
-            deprecateCmd: 'env:rename <name>',
-            options: [
-                {
-                    flags: '-e, --envId <envId>',
-                    desc: '环境 Id'
-                }
-            ],
-            desc: '修改云开发环境别名',
-            requiredEnvId: false
-        }
-    }
-
-    @InjectParams()
-    async execute(@EnvId() envId, @ArgsParams() params, @Log() log: Logger) {
-        log.verbose(params)
-
-        const name = params?.[0]
-        if (!name) {
-            throw new CloudBaseError('环境别名不能为空！')
-        }
-
-        await updateEnvInfo({
-            envId: envId,
-            alias: name
-        })
-
-        log.success('更新环境别名成功 ！')
-    }
-}

package/src/commands/env/create.ts

@@ -1,92 +0,0 @@
-import inquirer from 'inquirer'
-import { createEnv, getEnvLimit } from '../../env'
-import { loadingFactory, genClickableLink } from '../../utils'
-import { CloudBaseError } from '../../error'
-import { Command, ICommand } from '../common'
-import { InjectParams, ArgsParams } from '../../decorators'
-
-@ICommand()
-export class CreateCommand extends Command {
-    get options() {
-        return {
-            cmd: 'env',
-            childCmd: 'create <alias>',
-            deprecateCmd: 'env:create <alias>',
-            options: [],
-            desc: '创建云开发免费环境',
-            requiredEnvId: false
-        }
-    }
-
-    @InjectParams()
-    async execute(@ArgsParams() params) {
-        const alias = params?.[0]
-        if (!alias) {
-            throw new CloudBaseError('环境名称不能为空！')
-        }
-
-        const loading = loadingFactory()
-
-        // 检查环境限制数量
-        loading.start('检查中...')
-        const { CurrentFreeEnvNum, MaxFreeEnvNum, CurrentEnvNum, MaxEnvNum } = await getEnvLimit()
-        loading.stop()
-
-        if (+CurrentFreeEnvNum >= +MaxFreeEnvNum) {
-            const link = genClickableLink('https://console.cloud.tencent.com/tcb')
-            throw new CloudBaseError(
-                `免费环境数量已达上限，无法创建免费的环境，请到云开发-控制台中创建付费环境\n👉 ${link}`
-            )
-        }
-
-        if (+CurrentEnvNum >= +MaxEnvNum) {
-            throw new CloudBaseError('环境数量已达上限，无法创建新的环境！')
-        }
-
-        const { payment } = await inquirer.prompt({
-            type: 'list',
-            name: 'payment',
-            choices: [
-                {
-                    name: '按量计费（免费配额）',
-                    value: 'postpay'
-                },
-                {
-                    name: '包年包月（免费版本）',
-                    value: 'prepay'
-                }
-            ],
-            message: '请选择环境计费模式：',
-            default: 'postpay'
-        })
-
-        // 通过控制台授权登录的用户无订单支付权限
-        const { confirm } = await inquirer.prompt({
-            type: 'confirm',
-            name: 'confirm',
-            message:
-                '因支付权限问题，仅支持通过 API 秘钥登录的主账户使用 CLI 创建包年包月免费环境，其他用户需要登录控制台支付相关订单才能完成环境创建，是否继续？',
-            default: false
-        })
-
-        if (!confirm) {
-            throw new CloudBaseError('创建环境流程终止')
-        }
-
-        loading.start('环境创建中...')
-        try {
-            const res = await createEnv({
-                alias,
-                paymentMode: payment
-            })
-        } catch (e) {
-            if (e.code === 'ResourceInsufficient') {
-                throw new CloudBaseError('环境数量已达上限，无法创建新的环境！')
-            }
-            throw e
-        }
-
-        loading.succeed('创建环境成功，初始化预计需要花费 3 分钟')
-        console.log('你可以使用 cloudbase init 创建云开发项目')
-    }
-}