@cloudbase/cli 2.11.5 → 2.11.7

package/types/utils/ai/const.d.ts

@@ -0,0 +1,401 @@
+import z from 'zod/v3';
+export declare const CONFIG_PATH: string;
+export declare const ENV_LOCAL_PATH: string;
+export declare const CLAUDE_CODE_ROUTER_CONFIG_PATH: string;
+export declare const CLAUDE_CODE_ROUTER_LOG_PATH: string;
+export declare const CLAUDE_CODE_ROUTER_LOGS_DIR_PATH: string;
+export declare const CLOUDBASE_MCP_CONFIG_PATH: string;
+export declare const DEFAULT_CONFIG = "{\n  \"envId\": \"{{env.ENV_ID}}\"\n}";
+export declare const CLAUDE: {
+    name: string;
+    value: string;
+    configSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"none">;
+    }, "strip", z.ZodTypeAny, {
+        type?: "none";
+    }, {
+        type?: "none";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"custom">;
+        baseUrl: z.ZodString;
+        apiKey: z.ZodString;
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type?: "custom";
+        apiKey?: string;
+        model?: string;
+        baseUrl?: string;
+    }, {
+        type?: "custom";
+        apiKey?: string;
+        model?: string;
+        baseUrl?: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"cloudbase">;
+        provider: z.ZodString;
+        model: z.ZodString;
+        transformer: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "cloudbase";
+        transformer?: string;
+        model?: string;
+        provider?: string;
+    }, {
+        type?: "cloudbase";
+        transformer?: string;
+        model?: string;
+        provider?: string;
+    }>]>;
+};
+export declare const QWEN: {
+    name: string;
+    value: string;
+    configSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"none">;
+    }, "strip", z.ZodTypeAny, {
+        type?: "none";
+    }, {
+        type?: "none";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"custom">;
+        baseUrl: z.ZodString;
+        apiKey: z.ZodString;
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type?: "custom";
+        apiKey?: string;
+        model?: string;
+        baseUrl?: string;
+    }, {
+        type?: "custom";
+        apiKey?: string;
+        model?: string;
+        baseUrl?: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"cloudbase">;
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type?: "cloudbase";
+        model?: string;
+        provider?: string;
+    }, {
+        type?: "cloudbase";
+        model?: string;
+        provider?: string;
+    }>]>;
+};
+export declare const CODEX: {
+    name: string;
+    value: string;
+    configSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"none">;
+    }, "strip", z.ZodTypeAny, {
+        type?: "none";
+    }, {
+        type?: "none";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"custom">;
+        baseUrl: z.ZodString;
+        apiKey: z.ZodString;
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type?: "custom";
+        apiKey?: string;
+        model?: string;
+        baseUrl?: string;
+    }, {
+        type?: "custom";
+        apiKey?: string;
+        model?: string;
+        baseUrl?: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"cloudbase">;
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type?: "cloudbase";
+        model?: string;
+        provider?: string;
+    }, {
+        type?: "cloudbase";
+        model?: string;
+        provider?: string;
+    }>]>;
+};
+export declare const AIDER: {
+    name: string;
+    value: string;
+    configSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"custom">;
+        baseUrl: z.ZodString;
+        apiKey: z.ZodString;
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type?: "custom";
+        apiKey?: string;
+        model?: string;
+        baseUrl?: string;
+    }, {
+        type?: "custom";
+        apiKey?: string;
+        model?: string;
+        baseUrl?: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"cloudbase">;
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type?: "cloudbase";
+        model?: string;
+        provider?: string;
+    }, {
+        type?: "cloudbase";
+        model?: string;
+        provider?: string;
+    }>]>;
+};
+export declare const CURSOR: {
+    name: string;
+    value: string;
+    configSchema: z.ZodObject<{
+        type: z.ZodLiteral<"none">;
+    }, "strip", z.ZodTypeAny, {
+        type?: "none";
+    }, {
+        type?: "none";
+    }>;
+};
+export declare const CODEBUDDY: {
+    name: string;
+    value: string;
+    configSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"none">;
+    }, "strip", z.ZodTypeAny, {
+        type?: "none";
+    }, {
+        type?: "none";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"custom">;
+        apiKey: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "custom";
+        apiKey?: string;
+    }, {
+        type?: "custom";
+        apiKey?: string;
+    }>]>;
+};
+export declare const NONE: {
+    name: string;
+    value: string;
+};
+export declare const AGENTS: readonly [{
+    name: string;
+    value: string;
+    configSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"none">;
+    }, "strip", z.ZodTypeAny, {
+        type?: "none";
+    }, {
+        type?: "none";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"custom">;
+        baseUrl: z.ZodString;
+        apiKey: z.ZodString;
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type?: "custom";
+        apiKey?: string;
+        model?: string;
+        baseUrl?: string;
+    }, {
+        type?: "custom";
+        apiKey?: string;
+        model?: string;
+        baseUrl?: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"cloudbase">;
+        provider: z.ZodString;
+        model: z.ZodString;
+        transformer: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "cloudbase";
+        transformer?: string;
+        model?: string;
+        provider?: string;
+    }, {
+        type?: "cloudbase";
+        transformer?: string;
+        model?: string;
+        provider?: string;
+    }>]>;
+}, {
+    name: string;
+    value: string;
+    configSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"none">;
+    }, "strip", z.ZodTypeAny, {
+        type?: "none";
+    }, {
+        type?: "none";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"custom">;
+        apiKey: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "custom";
+        apiKey?: string;
+    }, {
+        type?: "custom";
+        apiKey?: string;
+    }>]>;
+}, {
+    name: string;
+    value: string;
+    configSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"none">;
+    }, "strip", z.ZodTypeAny, {
+        type?: "none";
+    }, {
+        type?: "none";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"custom">;
+        baseUrl: z.ZodString;
+        apiKey: z.ZodString;
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type?: "custom";
+        apiKey?: string;
+        model?: string;
+        baseUrl?: string;
+    }, {
+        type?: "custom";
+        apiKey?: string;
+        model?: string;
+        baseUrl?: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"cloudbase">;
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type?: "cloudbase";
+        model?: string;
+        provider?: string;
+    }, {
+        type?: "cloudbase";
+        model?: string;
+        provider?: string;
+    }>]>;
+}, {
+    name: string;
+    value: string;
+    configSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"none">;
+    }, "strip", z.ZodTypeAny, {
+        type?: "none";
+    }, {
+        type?: "none";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"custom">;
+        baseUrl: z.ZodString;
+        apiKey: z.ZodString;
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type?: "custom";
+        apiKey?: string;
+        model?: string;
+        baseUrl?: string;
+    }, {
+        type?: "custom";
+        apiKey?: string;
+        model?: string;
+        baseUrl?: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"cloudbase">;
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type?: "cloudbase";
+        model?: string;
+        provider?: string;
+    }, {
+        type?: "cloudbase";
+        model?: string;
+        provider?: string;
+    }>]>;
+}, {
+    name: string;
+    value: string;
+    configSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"custom">;
+        baseUrl: z.ZodString;
+        apiKey: z.ZodString;
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type?: "custom";
+        apiKey?: string;
+        model?: string;
+        baseUrl?: string;
+    }, {
+        type?: "custom";
+        apiKey?: string;
+        model?: string;
+        baseUrl?: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"cloudbase">;
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type?: "cloudbase";
+        model?: string;
+        provider?: string;
+    }, {
+        type?: "cloudbase";
+        model?: string;
+        provider?: string;
+    }>]>;
+}, {
+    name: string;
+    value: string;
+    configSchema: z.ZodObject<{
+        type: z.ZodLiteral<"none">;
+    }, "strip", z.ZodTypeAny, {
+        type?: "none";
+    }, {
+        type?: "none";
+    }>;
+}, {
+    name: string;
+    value: string;
+}];
+export declare const CLOUDBASE_PROVIDERS: readonly [{
+    readonly name: "Kimi";
+    readonly value: "kimi-exp";
+    readonly models: readonly ["kimi-k2-instruct-local"];
+    readonly transformer: any;
+}, {
+    readonly name: "DeepSeek";
+    readonly value: "deepseek";
+    readonly models: readonly ["deepseek-v3"];
+    readonly transformer: "deepseek";
+}, {
+    readonly name: "LongCat";
+    readonly value: "longcat";
+    readonly models: readonly ["LongCat-Flash-Chat"];
+    readonly transformer: any;
+}];
+export declare function getDefaultConfig(agent: string): unknown;
+export declare function getAgentConfigValidator(agent: string): (x: unknown) => {
+    success: true;
+} | {
+    success: false;
+    error: unknown;
+};
+export declare const BASE_URL_MODEL_MAPPING: {
+    readonly 'https://api.moonshot.cn/v1': "kimi-k2-0711-preview";
+    readonly 'https://open.bigmodel.cn/api/paas/v4': "glm-4.5";
+    readonly 'https://api.longcat.chat/openai': "LongCat-Flash-Chat";
+};
+export declare function getDefaultModelByBaseUrl(baseUrl: string): string;
+export declare function getBooleanHint(defaultValue?: boolean): string;
+export declare const LIST_HINT: string;

package/types/utils/ai/ensureFiles.d.ts

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

package/types/utils/ai/env.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '../log';
+export declare function ensureValidEnv(_envId: string, log: Logger): Promise<string>;

package/types/utils/ai/envLocalManager.d.ts

@@ -0,0 +1,23 @@
+export interface AIEnvConfig {
+    defaultAgent: string;
+    agents: {
+        [agentName: string]: {
+            apiKey?: string;
+            baseUrl?: string;
+            model?: string;
+        };
+    };
+}
+export declare class EnvLocalManager {
+    updateEnvId(envId: string): void;
+    parseEnvFile(): Promise<Record<string, string>>;
+    updateAIConfig(aiConfig: AIEnvConfig): Promise<void>;
+    removeAIConfig(agentName?: string): Promise<void>;
+    validateAIConfig(aiConfig: AIEnvConfig): string[];
+    updateDefaultAgent(agent: string): void;
+    setEnvLocal(key: string, value: string): void;
+    removeEnvLocal(key: string): void;
+    private removeAIConfigFromMap;
+    private removeSpecificAgentConfig;
+    private addAIConfigToEnv;
+}

package/types/utils/ai/nodeVersion.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '../log';
+export declare function ensureNodeVersion(version: string, log: Logger): void;

package/types/utils/ai/router.d.ts

@@ -0,0 +1,59 @@
+import { Logger } from '../log';
+export interface IdeFileDescriptor {
+    path: string;
+    isMcpConfig?: boolean;
+}
+interface IExecute {
+    agent?: string;
+    envId?: string;
+    addtionalArgs: string[];
+    log: Logger;
+    template?: string;
+    useDefaultConfig?: boolean;
+}
+export declare class AICommandRouter {
+    private configManager;
+    constructor();
+    execute({ agent, addtionalArgs, log, template, useDefaultConfig }: IExecute): Promise<void>;
+    private checkToolkitConfig;
+    private checkSkipTemplateConfig;
+    private saveSkipTemplateConfig;
+    private downloadTemplate;
+    private downloadAndExtractTemplate;
+    private getInstallCommand;
+    private executeCommand;
+    private isToolAvailable;
+    private validateAgentConfig;
+    private executeAgentWithConfig;
+    private executeClaudeAgent;
+    private executeNoneClaudeAgent;
+    private executeQwenAgent;
+    private executeNoneQwenAgent;
+    private executeQwenCloudbaseAgent;
+    private executeClaudeCloudbaseAgent;
+    private restartClaudeCodeRouter;
+    private isClaudeCodeRouterRunning;
+    private configureClaudeCodeRouter;
+    private parseArgs;
+    private ensureClaudeCodeRouter;
+    private ensureClaudeCode;
+    private ensureQwenCode;
+    private executeCodexAgent;
+    private executeNoneCodexAgent;
+    private executeCodexCloudbaseAgent;
+    private executeNoneCursorAgent;
+    private ensureCursor;
+    private ensureCodexCode;
+    private executeAiderAgent;
+    private executeAiderCloudbaseAgent;
+    private ensureAider;
+    private modifyMCPConfigs;
+    private modifyMCPJsonFile;
+    private modifyMCPTomlFile;
+    private mergeMcpConfig;
+    private objectToToml;
+    private executeCodebuddyAgent;
+    private executeNoneCodebuddyAgent;
+    private ensureCodebuddy;
+}
+export {};

package/types/utils/ai/setup.d.ts

@@ -0,0 +1,26 @@
+import { Logger } from '../log';
+export declare class AISetupWizard {
+    private aiConfigManager;
+    private envId?;
+    constructor(envId?: string);
+    setUpDefault(log: Logger, agent?: string): Promise<{
+        defaultAgent: string;
+    }>;
+    setUp(log: Logger): Promise<{
+        defaultAgent: string;
+    }>;
+    configureEnvId(log: Logger, _envId: string): Promise<string>;
+    private selectDefaultAgent;
+    private selectCurrentAgent;
+    private showConfigInfo;
+    private selectAgent;
+    private configureAgent;
+    private configureClaudeAgent;
+    private configureQwenAgent;
+    private configureCodexAgent;
+    private configureAiderAgent;
+    private configureCursorAgent;
+    private ensureGitignore;
+    private selectCloudBaseProvider;
+    private configureCodebuddyAgent;
+}

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/checkTcbrEnv.d.ts

@@ -0,0 +1,3 @@
+import { EnumEnvCheck } from '../constant';
+export declare function checkTcbrEnv(envId: string | undefined, isTcbr: boolean): Promise<EnumEnvCheck> | never;
+export declare function logEnvCheck(envId: string, warningType: EnumEnvCheck): void;

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/commonParamsCheck.d.ts

@@ -0,0 +1,3 @@
+import { ITcbrServiceOptionalOptions, ITcbrServiceConvertedOptionalOptions } from '../types';
+export declare function parseOptionalParams(options: ITcbrServiceOptionalOptions): ITcbrServiceConvertedOptionalOptions;
+export declare function parseInputParam(originalParam: any, override: boolean, handler: Function | null, overrideVal: any, defaultVal: any, ...args: any[]): any;

package/types/utils/config.d.ts

@@ -0,0 +1,27 @@
+import { Arguments } from 'yargs';
+import { ICloudBaseConfig } from '@cloudbase/toolbox';
+import { Credential } from '../types';
+export interface IArgs {
+    envId: string;
+    region: string;
+    verbose: boolean;
+    configPath: string;
+    [x: string]: unknown;
+}
+export declare const getArgs: () => Arguments<IArgs>;
+export declare function getPrivateSettings(config: ICloudBaseRcSettings, cmd?: string): undefined | IPrivateSettings;
+type IAbsUrl = `http://${string}` | `https://${string}`;
+export interface IPrivateSettings {
+    credential: Credential;
+    endpoints: {
+        editor: IAbsUrl;
+        cliApi: IAbsUrl;
+    };
+    privateUin: string;
+}
+export interface ICloudBaseRcSettings extends ICloudBaseConfig {
+    privateSettings?: IPrivateSettings;
+    ai?: any;
+}
+export declare const getCloudBaseConfig: (configPath?: string) => Promise<ICloudBaseRcSettings>;
+export {};

package/types/utils/debug-logger.d.ts

@@ -0,0 +1 @@
+export declare function debugLogger(req: unknown, resp: unknown, startTime: Date, endTime: Date, writeToLocal?: boolean): void;

package/types/utils/dts.d.ts

@@ -0,0 +1,6 @@
+import { type JSONSchema } from 'json-schema-to-typescript';
+export declare function generateDataModelDTS(dataModelList: {
+    name: string;
+    title: string;
+    schema: JSONSchema;
+}[]): Promise<string>;

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 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,22 @@
+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';
+export * from './url';
+export * from './tcbrApi';
+export * from './checkTcbrEnv';
+export * from './commonParamsCheck';

package/types/utils/log.d.ts

@@ -0,0 +1,22 @@
+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;
+    debug(...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/mcp-config-modifier.d.ts

@@ -0,0 +1,7 @@
+import { Logger } from './log';
+export declare class MCPConfigModifier {
+    modifyMCPConfigs(extractDir: string, log: Logger): Promise<void>;
+    private modifyMCPJsonFile;
+    private modifyMCPTomlFile;
+    private objectToToml;
+}

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>;
+}