@cloudbase/cli 2.11.6 → 2.11.7

package/templates/server/node/cloudbaserc.json

@@ -0,0 +1,10 @@
+{
+    "envId": "{{envId}}",
+    "servers": [
+        {
+            "type": "node",
+            "name": "helloworld",
+            "path": "./"
+        }
+    ]
+}

package/templates/server/node/index.js

@@ -0,0 +1,6 @@
+const express = require('express')
+const app = express()
+
+app.get('/', (req, res) => res.send('Hello World!'))
+
+app.listen(5000, () => console.log('Example app listening on port 5000!'))

package/templates/server/node/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "helloworld",
+  "version": "0.0.1",
+  "description": "helloworld for cloudbase",
+  "main": "index.js",
+  "dependencies": {
+    "express": "^4.16.4"
+  }
+}

package/test-mcp-integration.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const fs = require('fs-extra');
+
+// 模拟 Logger
+const mockLogger = {
+    info: (...args) => console.log('ℹ️', ...args),
+    warn: (...args) => console.log('⚠️', ...args),
+    error: (...args) => console.log('❌', ...args),
+    debug: (...args) => console.log('🔍', ...args),
+    log: (...args) => console.log(...args)
+};
+
+async function testMCPIntegration() {
+    console.log('🧪 测试 MCP 配置修改功能...\n');
+    
+    try {
+        // 动态导入 MCPConfigModifier
+        const { MCPConfigModifier } = await import('./lib/utils/mcp-config-modifier.js');
+        
+        const mcpConfigModifier = new MCPConfigModifier();
+        const testDir = path.join(__dirname, 'test-demo');
+        
+        console.log(`📁 测试目录: ${testDir}`);
+        
+        // 检查测试文件是否存在
+        const files = [
+            '.cursor/mcp.json',
+            '.vscode/mcp.json',
+            '.codex/config.toml'
+        ];
+        
+        console.log('\n📋 测试前的文件内容:');
+        for (const file of files) {
+            const filePath = path.join(testDir, file);
+            if (await fs.pathExists(filePath)) {
+                const content = await fs.readFile(filePath, 'utf-8');
+                console.log(`\n${file}:`);
+                console.log(content);
+            }
+        }
+        
+        // 执行 MCP 配置修改
+        console.log('\n🔧 执行 MCP 配置修改...');
+        await mcpConfigModifier.modifyMCPConfigs(testDir, mockLogger);
+        
+        // 检查修改后的文件
+        console.log('\n📋 测试后的文件内容:');
+        for (const file of files) {
+            const filePath = path.join(testDir, file);
+            if (await fs.pathExists(filePath)) {
+                const content = await fs.readFile(filePath, 'utf-8');
+                console.log(`\n${file}:`);
+                console.log(content);
+            }
+        }
+        
+        console.log('\n✅ MCP 配置修改测试完成！');
+        
+    } catch (error) {
+        console.error('❌ 测试失败:', error);
+        process.exit(1);
+    }
+}
+
+// 运行测试
+testMCPIntegration();

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es2015",
+        "moduleResolution": "node",
+        "outDir": "lib",
+        "removeComments": true,
+        "types": ["node"],
+        "skipLibCheck": true,
+        "esModuleInterop": true,
+        "declaration": true,
+        "declarationDir": "./types",
+        "experimentalDecorators": true,
+        "emitDecoratorMetadata": true,
+        "newLine": "LF",
+        "resolveJsonModule": true
+    },
+    "include": ["src/**/*"],
+    "exclude": ["node_modules", "test"]
+}

package/tsconfig.test.json

@@ -0,0 +1,13 @@
+{
+    "compileOnSave": true,
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "ES2017",
+        "moduleResolution": "node",
+        "outDir": "lib",
+        "types": ["node", "jest"],
+        "esModuleInterop": true
+    },
+    "include": ["src/**/*", "test/**/*"],
+    "exclude": ["node_modules", "test"]
+}

package/types/auth/index.d.ts

@@ -0,0 +1,2 @@
+export * from './login';
+export * from './logout';

package/types/auth/login.d.ts

@@ -0,0 +1,25 @@
+import { Credential } from '@cloudbase/toolbox';
+import { ILoginOptions } from '../types';
+export declare function loginByWebAuth(): Promise<{
+    code: string;
+    msg: string;
+} | {
+    code: string;
+    msg: string;
+    credential: Credential;
+    error?: undefined;
+} | {
+    code: string;
+    msg: string;
+    error: any;
+}>;
+export declare function loginWithKey(secretId?: string, secretKey?: string, token?: string): Promise<{
+    code: string;
+    msg: string;
+}>;
+export declare function login(options?: ILoginOptions): Promise<{
+    code: string;
+    msg: string;
+    credential?: Credential;
+}>;
+export declare function checkLogin(): Promise<void>;

package/types/auth/logout.d.ts

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

package/types/commands/account/index.d.ts

@@ -0,0 +1,2 @@
+export * from './login';
+export * from './logout';

package/types/commands/account/login.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '../common';
+import { Logger } from '../../decorators';
+export declare class LoginCommand extends Command {
+    get options(): {
+        cmd: string;
+        options: {
+            flags: string;
+            desc: string;
+        }[];
+        desc: string;
+        requiredEnvId: boolean;
+        withoutAuth: boolean;
+    };
+    execute(options: any, log: Logger): Promise<never>;
+}

package/types/commands/account/logout.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '../common';
+import { Logger } from '../../decorators';
+export declare class LogoutCommand extends Command {
+    get options(): {
+        cmd: string;
+        options: any[];
+        desc: string;
+        requiredEnvId: boolean;
+        withoutAuth: boolean;
+    };
+    execute(log: Logger): Promise<void>;
+}

package/types/commands/ai/index.d.ts

@@ -0,0 +1,23 @@
+import { Command } from '../common';
+import { ICommandContext } from '../../types';
+import { Logger } from '../../utils/log';
+export declare class AICommand extends Command {
+    get options(): {
+        cmd: string;
+        options: {
+            flags: string;
+            desc: string;
+        }[];
+        desc: string;
+        requiredEnvId: boolean;
+        withoutAuth: boolean;
+        allowUnknownOption: boolean;
+    };
+    execute(options: any, ctx: ICommandContext, log: Logger): Promise<void | {
+        defaultAgent: string;
+    }>;
+    private resetConfig;
+    private showConfig;
+    private parseArgs;
+    private getSubCommand;
+}

package/types/commands/cloudfunction/base.d.ts

@@ -0,0 +1,43 @@
+import { Logger } from '../../decorators';
+import { Command } from '../common';
+export declare class CloudFunctionDeployCommand extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: {
+            flags: string;
+            desc: string;
+        }[];
+        requiredEnvId: boolean;
+        autoRunLogin: boolean;
+        desc: string;
+    };
+    execute(ctx: any, envId: any, log: Logger, options: any): Promise<void>;
+}
+export declare class CloudFunctionDownloadCommand extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: {
+            flags: string;
+            desc: string;
+        }[];
+        requiredEnvId: boolean;
+        autoRunLogin: boolean;
+        desc: string;
+    };
+    execute(ctx: any, envId: any, log: Logger, options: any): Promise<void>;
+}
+export declare class CloudFunctionRunCommand extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: {
+            flags: string;
+            desc: string;
+        }[];
+        requiredEnvId: boolean;
+        desc: string;
+    };
+    execute(logger: Logger, ctx: any, options: any): Promise<void>;
+}

package/types/commands/cloudfunction/index.d.ts

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

package/types/commands/cloudrun/base.d.ts

@@ -0,0 +1,160 @@
+import { Logger } from '../../decorators';
+import { Command } from '../common';
+export declare function getCloudrunService(envId: string): Promise<import("@cloudbase/manager-node/types/cloudrun").CloudRunService>;
+export declare function getAgentService(envId: string): Promise<import("@cloudbase/manager-node/types/agent").AgentService>;
+export declare class CloudRunInitCommand extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: {
+            flags: string;
+            desc: string;
+        }[];
+        requiredEnvId: boolean;
+        autoRunLogin: boolean;
+        desc: string;
+    };
+    execute(ctx: any, envId: string, log: Logger, options: {
+        serviceName?: string;
+        targetPath?: string;
+        template?: string;
+    }): Promise<void>;
+}
+export declare class CloudRunListCommand extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: ({
+            flags: string;
+            desc: string;
+            defaultValue?: undefined;
+            choices?: undefined;
+        } | {
+            flags: string;
+            desc: string;
+            defaultValue: number;
+            choices?: undefined;
+        } | {
+            flags: string;
+            desc: string;
+            choices: string[];
+            defaultValue?: undefined;
+        })[];
+        requiredEnvId: boolean;
+        autoRunLogin: boolean;
+        desc: string;
+    };
+    execute(ctx: any, envId: string, log: Logger, options: {
+        pageSize?: string;
+        pageNum?: string;
+        serviceName?: string;
+        serverType?: string;
+    }): Promise<void>;
+}
+export declare class CloudRunDownloadCommand extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: ({
+            flags: string;
+            desc: string;
+            required?: undefined;
+            defaultValue?: undefined;
+        } | {
+            flags: string;
+            desc: string;
+            required: boolean;
+            defaultValue?: undefined;
+        } | {
+            flags: string;
+            desc: string;
+            defaultValue: string;
+            required?: undefined;
+        } | {
+            flags: string;
+            desc: string;
+            defaultValue: boolean;
+            required?: undefined;
+        })[];
+        requiredEnvId: boolean;
+        autoRunLogin: boolean;
+        desc: string;
+    };
+    execute(ctx: any, envId: string, log: Logger, options: {
+        serviceName: string;
+        targetPath: string;
+        force: boolean;
+    }): Promise<void>;
+}
+export declare class CloudRunDeleteCommand extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: ({
+            flags: string;
+            desc: string;
+            required?: undefined;
+            defaultValue?: undefined;
+        } | {
+            flags: string;
+            desc: string;
+            required: boolean;
+            defaultValue?: undefined;
+        } | {
+            flags: string;
+            desc: string;
+            defaultValue: boolean;
+            required?: undefined;
+        })[];
+        requiredEnvId: boolean;
+        autoRunLogin: boolean;
+        desc: string;
+    };
+    execute(ctx: any, envId: string, log: Logger, options: {
+        serviceName: string;
+        force: boolean;
+    }): Promise<void>;
+}
+export declare class CloudRunDeployCommand extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: ({
+            flags: string;
+            desc: string;
+            defaultValue?: undefined;
+        } | {
+            flags: string;
+            desc: string;
+            defaultValue: boolean;
+        })[];
+        requiredEnvId: boolean;
+        autoRunLogin: boolean;
+        desc: string;
+    };
+    execute(ctx: any, envId: string, log: Logger, options: {
+        serviceName?: string;
+        source?: string;
+        force?: boolean;
+        port?: number;
+        createAgent?: boolean;
+        installDependency?: string;
+    }): Promise<void>;
+}
+export declare class CloudRunRunCommand extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        allowUnknownOption: boolean;
+        options: {
+            flags: string;
+            desc: string;
+        }[];
+        requiredEnvId: boolean;
+        desc: string;
+    };
+    execute(envId: string, logger: Logger, ctx: any, options: any): Promise<void>;
+    private checkAndRunTsc;
+    private openDebugApp;
+    private waitForPort;
+}

package/types/commands/cloudrun/index.d.ts

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

package/types/commands/common.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { ICommandContext } from '../types';
+interface ICommandOption {
+    flags: string;
+    desc: string;
+    hideHelp?: boolean;
+}
+export interface ICommandOptions {
+    deprecateCmd?: string;
+    cmd: string;
+    allowUnknownOption?: boolean;
+    childCmd?: string | {
+        cmd: string;
+        desc: string;
+    };
+    childSubCmd?: string;
+    options: ICommandOption[];
+    desc: string;
+    requiredEnvId?: boolean;
+    withoutAuth?: boolean;
+    autoRunLogin?: boolean;
+}
+interface ICommandDecoratorOptions {
+    supportPrivate: boolean | 'only';
+}
+export declare function ICommand(options?: ICommandDecoratorOptions): ClassDecorator;
+export declare function registerCommands(): Promise<void>;
+export declare abstract class Command extends EventEmitter {
+    on(event: 'preHandle' | 'afterHandle', listener: (ctx: ICommandContext, args: any[]) => void): this;
+    init(): void;
+    private createProgram;
+    private preHandle;
+    private afterHandle;
+    abstract execute(...args: any[]): void;
+    abstract get options(): ICommandOptions;
+}
+export {};

package/types/commands/config/delete.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '../common';
+import { Logger } from '../../decorators';
+export declare class ConfigDeleteCommand extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: any[];
+        desc: string;
+        requiredEnvId: boolean;
+        withoutAuth: boolean;
+    };
+    execute(params: any[], log: Logger): Promise<void>;
+}

package/types/commands/config/get.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '../common';
+import { Logger } from '../../decorators';
+export declare class ConfigGetCommand extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: any[];
+        desc: string;
+        requiredEnvId: boolean;
+        withoutAuth: boolean;
+    };
+    execute(params: any[], log: Logger): Promise<void>;
+}

package/types/commands/config/index.d.ts

@@ -0,0 +1,5 @@
+export * from './set';
+export * from './get';
+export * from './delete';
+export * from './list';
+export * from './interface';

package/types/commands/config/interface.d.ts

@@ -0,0 +1,17 @@
+export type IConfigItem = {
+    key: string;
+    description?: string;
+    envKey?: string;
+} & ({
+    type: 'string';
+    value: string;
+} | {
+    type: 'number';
+    value: number;
+} | {
+    type: 'boolean';
+    value: boolean;
+});
+export declare const CONFIGS: Record<string, IConfigItem>;
+export declare const DEFAULT_CONFIGS: any;
+export type ConfigAction = 'set' | 'get' | 'delete' | 'list';

package/types/commands/config/list.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '../common';
+import { Logger } from '../../decorators';
+export declare class ConfigListCommand extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: any[];
+        desc: string;
+        requiredEnvId: boolean;
+        withoutAuth: boolean;
+    };
+    execute(log: Logger): Promise<void>;
+}

package/types/commands/config/set.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '../common';
+import { Logger } from '../../decorators';
+export declare class ConfigSetCommand extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: any[];
+        desc: string;
+        requiredEnvId: boolean;
+        withoutAuth: boolean;
+    };
+    execute(params: any[], log: Logger): Promise<void>;
+}

package/types/commands/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const EnvSource: {
+    MINIAPP: string;
+    QCLOUD: string;
+};
+export declare const EnvStatus: {
+    NORMAL: string;
+    UNAVAILABLE: string;
+};

package/types/commands/db/base.d.ts

@@ -0,0 +1,44 @@
+import { Command } from '../common';
+import { Logger } from '../../decorators';
+export declare class DbListCommand extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: {
+            flags: string;
+            desc: string;
+        }[];
+        requiredEnvId: boolean;
+        autoRunLogin: boolean;
+        desc: string;
+    };
+    execute(envId: any, log: Logger): Promise<void>;
+}
+export declare class DbPullCommand extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: {
+            flags: string;
+            desc: string;
+        }[];
+        requiredEnvId: boolean;
+        autoRunLogin: boolean;
+        desc: string;
+    };
+    execute(envId: any, params: any, log: Logger): Promise<void>;
+}
+export declare class DbPushCommand extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        options: {
+            flags: string;
+            desc: string;
+        }[];
+        requiredEnvId: boolean;
+        autoRunLogin: boolean;
+        desc: string;
+    };
+    execute(envId: any, params: any, log: Logger): Promise<void>;
+}

package/types/commands/db/index.d.ts

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

package/types/commands/env/base.d.ts

@@ -0,0 +1,27 @@
+import { Command } from '../common';
+import { Logger } from '../../decorators';
+export declare class EnvListCommand extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        deprecateCmd: string;
+        options: any[];
+        desc: string;
+        requiredEnvId: boolean;
+    };
+    execute(log: Logger): Promise<void>;
+}
+export declare class EnvRenameCommand extends Command {
+    get options(): {
+        cmd: string;
+        childCmd: string;
+        deprecateCmd: string;
+        options: {
+            flags: string;
+            desc: string;
+        }[];
+        desc: string;
+        requiredEnvId: boolean;
+    };
+    execute(envId: any, params: any, log: Logger): Promise<void>;
+}