@vectorx/cloud-toolkit 0.0.0-beta-20260108133839 → 0.0.0-beta-20260320063305

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectorx/cloud-toolkit",
-  "version": "0.0.0-beta-20260108133839",
+  "version": "0.0.0-beta-20260320063305",
   "description": "VectorX Cloud Toolkit",
   "main": "lib/index.js",
   "types": "types/index.d.ts",
@@ -18,12 +18,11 @@
   "author": "",
   "license": "ISC",
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   },
   "dependencies": {
-    "@vectorx/agent-simulator": "0.0.0-beta-20260108133839",
-    "@vectorx/functions-framework": "0.0.0-beta-20260108133839",
     "archiver": "^5.3.1",
+    "cli-table3": "^0.5.1",
     "cos-nodejs-sdk-v5": "2.x",
     "crypto": "^1.0.1",
     "dayjs": "^1.11.13",
@@ -38,7 +37,17 @@
     "ora": "^4.0.2",
     "semver": "^7.5.4",
     "terminal-link": "^2.1.1",
-    "uuid": "^11.1.0"
+    "uuid": "^11.1.0",
+    "@vectorx/cloud-database-client": "0.0.0-beta-20260320063305",
+    "@vectorx/endpoints": "0.0.0-beta-20260320063305"
+  },
+  "peerDependencies": {
+    "@vectorx/functions-framework": "*"
+  },
+  "peerDependenciesMeta": {
+    "@vectorx/functions-framework": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@types/archiver": "^5.3.2",
@@ -50,6 +59,5 @@
     "dev": "rimraf lib types && tsc -w && cp -r src/utils/*.applescript lib/utils/",
     "build": "rimraf lib types && tsc --resolveJsonModule && cp -r src/utils/*.applescript lib/utils/",
     "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "readme": "### 云开发工具集合"
+  }
 }

package/types/agent.kit.d.ts

@@ -1,11 +1,33 @@
+import type { LogCollector } from "./fun.kit";
+type AgentSimulatorCtor = new (opts: {
+    port: number;
+    agentServerUrl: string;
+    open: boolean;
+    quiet?: boolean;
+    agentId?: string;
+}) => {
+    start(): Promise<void>;
+};
 export interface AgentDevOptions {
     workDir?: string;
     port?: number;
     simulatorPort?: number;
+    idePort?: number;
     watch?: boolean;
     open?: boolean;
     nodePath?: string;
     enableRedLangfuse?: boolean;
+    mode?: "agent" | "fun";
+    useIde?: boolean;
+    deps?: {
+        AgentSimulator?: AgentSimulatorCtor;
+        startFunctionDebugger?: (opts: any) => Promise<{
+            uiUrl: string;
+            apiUrl: string;
+            wsUrl: string;
+            close: () => Promise<void>;
+        }>;
+    };
 }
 export interface IUploadOptions {
     version: string;
@@ -18,6 +40,7 @@ export interface AgentBuildOptions {
     upload?: boolean;
     validator?: IProjectValidator;
     uploadInfo?: IUploadOptions;
+    logCollector?: LogCollector;
 }
 export interface AgentNewOptions {
     projectName: string;
@@ -56,11 +79,19 @@ export interface IDeployService {
 }
 export declare function startRcbFramework(workDir: string, port: number, watch: boolean, nodePath?: string, options?: {
     enableRedLangfuse?: boolean;
-}): Promise<void>;
+    mode?: "agent" | "fun";
+}, onLog?: (log: {
+    level: "info" | "error" | "warn";
+    message: string;
+    timestamp: string;
+}) => void): Promise<void>;
 export declare function startDev(options: AgentDevOptions): Promise<{
     port: number;
     simulatorPort: number;
-    simulator: any;
+    simulator: {
+        start(): Promise<void>;
+    };
+    ideUrl: string;
     rcbProcess: any;
 }>;
 export declare function build(options: AgentBuildOptions): Promise<BuildResult>;
@@ -68,3 +99,15 @@ export declare function createNew(options: AgentNewOptions): Promise<{
     projectDir: string;
 }>;
 export declare function cleanup(): void;
+export interface AgentInfoResult {
+    agentId: string;
+    agentName: string;
+    agentIcon: string;
+}
+export declare function getAgentInfo(workDir?: string): Promise<AgentInfoResult>;
+export type { AgentListItem, AgentDetail } from "./container/types";
+export declare function getAgentList(params?: {
+    pageNo?: number;
+    pageSize?: number;
+}): Promise<import("./container/types").AgentListItem[]>;
+export declare function getAgentInfoById(agentId: string): Promise<import("./container/types").AgentDetail | null>;

package/types/cloud-dev.kit.d.ts

@@ -0,0 +1,18 @@
+import type { CloudDevUserInfo, LangfuseConfigResult } from "./container";
+export type { LangfuseConfigResult, CloudDevUserInfo };
+export declare function getLangfuseConfig(params?: {
+    secret_id?: string;
+    cli_token?: string;
+}): Promise<LangfuseConfigResult>;
+export declare function getCloudDevLLMBaseURL(params?: {
+    secret_id?: string;
+    cli_token?: string;
+}): string;
+export declare function getCloudDevAnthropicLLMBaseURL(params?: {
+    secret_id?: string;
+    cli_token?: string;
+}): string;
+export declare function getUserInfo(params?: {
+    secret_id?: string;
+    cli_token?: string;
+}): Promise<CloudDevUserInfo>;

package/types/config/api.config.d.ts

@@ -1,2 +1 @@
-declare function getBaseUrl(): string;
-export { getBaseUrl };
+export declare function getBaseUrl(): string;

package/types/container/identifiers.d.ts

@@ -1,6 +1,11 @@
 import type { ServiceIdentifier } from "inversify";
-import type { IAuthService, IUploadService } from "./types";
+import type { IAgentService, IAuthService, ICloudDevService, ICloudEnvService, IDatabaseService, IFunService, IUploadService } from "./types";
 export declare const SERVICE_IDENTIFIERS: {
     AuthService: ServiceIdentifier<IAuthService>;
     UploadService: ServiceIdentifier<IUploadService>;
+    CloudEnvService: ServiceIdentifier<ICloudEnvService>;
+    CloudDevService: ServiceIdentifier<ICloudDevService>;
+    FunService: ServiceIdentifier<IFunService>;
+    DatabaseService: ServiceIdentifier<IDatabaseService>;
+    AgentService: ServiceIdentifier<IAgentService>;
 };

package/types/container/index.d.ts

@@ -1,9 +1,14 @@
 import { container } from "./container";
 import { SERVICE_IDENTIFIERS } from "./identifiers";
-import type { IAuthService, IUploadService } from "./types";
+import type { IAgentService, IAuthService, ICloudDevService, ICloudEnvService, IDatabaseService, IFunService, IUploadService } from "./types";
 export declare class ServiceProvider {
     static getAuthService(): IAuthService;
     static getUploadService(): IUploadService;
+    static getCloudEnvService(): ICloudEnvService;
+    static getCloudDevService(): ICloudDevService;
+    static getFunService(): IFunService;
+    static getDatabaseService(): IDatabaseService;
+    static getAgentService(): IAgentService;
 }
 export { container, SERVICE_IDENTIFIERS };
 export * from "./types";

package/types/container/types.d.ts

@@ -1,3 +1,7 @@
+import type { DatabaseClient } from "@vectorx/cloud-database-client";
+import type { DatabaseRequestContext, DbColumn, DbPreviewOptions, DbTable, DbTablePreview, SqlQuery } from "../database.kit";
+import type { CloudEnvironment, CloudEnvironmentCreateRequest, CloudEnvironmentUpdateRequest } from "../env.kit";
+import type { FunDeployOptions, FunDeployResult, FunDevOptions, FunDevRuntime } from "../fun.kit";
 import type { CheckStatusRequest, CheckStatusResponse } from "../services/auth-service";
 import type { BuildPreCheckResponse, IBuildPreCheckParams, IDeployParams } from "../services/upload-service";
 export interface IAuthService {
@@ -11,9 +15,129 @@ export interface IUploadService {
     buildPreCheck(params: IBuildPreCheckParams): Promise<BuildPreCheckResponse>;
     deploy(params: IDeployParams): Promise<any>;
 }
+export interface ICloudEnvService {
+    getCloudEnvironments(cloudEnvId?: string): Promise<CloudEnvironment[]>;
+    getCloudEnvironment(cloudEnvId: string): Promise<CloudEnvironment | null>;
+    createCloudEnvironment(payload: CloudEnvironmentCreateRequest): Promise<CloudEnvironment>;
+    updateCloudEnvironment(payload: CloudEnvironmentUpdateRequest): Promise<CloudEnvironment>;
+}
+export interface IFunService {
+    startFunDev(options?: FunDevOptions): Promise<FunDevRuntime>;
+    deploy(options: FunDeployOptions): Promise<FunDeployResult>;
+    getPublishHistory(options: {
+        envId: string;
+        pageNo?: number;
+        pageSize?: number;
+    }): Promise<{
+        pkgList: Array<{
+            cloud_env_id: string;
+            desc: string;
+            resource_id: string;
+            committer_id: string;
+            committer_name: string;
+            committer_time: number;
+        }>;
+        total: number;
+    }>;
+}
+export interface IDatabaseService {
+    getOrCreateClient(ctx: DatabaseRequestContext): Promise<DatabaseClient>;
+    listTables(ctx: DatabaseRequestContext, params?: {
+        schema?: string;
+    }): Promise<{
+        tables: DbTable[];
+    }>;
+    getTableColumns(ctx: DatabaseRequestContext, params: {
+        schema?: string;
+        table: string;
+    }): Promise<{
+        columns: DbColumn[];
+    }>;
+    previewTable(ctx: DatabaseRequestContext, params: {
+        schema?: string;
+        table: string;
+        options?: DbPreviewOptions;
+    }): Promise<{
+        preview: DbTablePreview;
+    }>;
+    executeSql(ctx: DatabaseRequestContext, q: SqlQuery): Promise<{
+        rows: any[];
+        rowCount?: number;
+    }>;
+}
+export interface ICloudDevService {
+    getLangfuseConfig(params?: {
+        secret_id?: string;
+        cli_token?: string;
+    }): Promise<LangfuseConfigResult>;
+    getCloudDevLLMBaseURL(params?: {
+        secret_id?: string;
+        cli_token?: string;
+    }): string;
+    getCloudDevAnthropicLLMBaseURL(params?: {
+        secret_id?: string;
+        cli_token?: string;
+    }): string;
+    getUserInfo(params?: {
+        secret_id?: string;
+        cli_token?: string;
+    }): Promise<CloudDevUserInfo>;
+}
+export interface LangfuseConfigResult {
+    secretKey: string;
+    publicKey: string;
+    baseUrl?: string;
+}
+export interface CloudDevUserInfo {
+    nick?: string;
+    nickname?: string;
+    user_id?: string;
+    avatar?: string;
+    desc?: string;
+    [key: string]: unknown;
+}
+export interface AgentListItem {
+    agentId: string;
+    agentName: string;
+    agentType?: string;
+    status?: string;
+    createTime?: string;
+    updateTime?: string;
+    [key: string]: unknown;
+}
+export interface AgentDetail {
+    agentId: string;
+    agentName: string;
+    agentAvatar?: string;
+    agentType?: string;
+    description?: string;
+    status?: string;
+    config?: Record<string, unknown>;
+    createTime?: string;
+    updateTime?: string;
+    creator?: string;
+    [key: string]: unknown;
+}
+export interface IAgentService {
+    getAgentList(params?: {
+        pageNo?: number;
+        pageSize?: number;
+    }): Promise<AgentListItem[]>;
+    getAgentInfoById(agentId: string): Promise<AgentDetail | null>;
+}
+export interface CloudEnvInfo {
+    cloud_env_name: string;
+    status: number;
+    cloud_env_id: string;
+    description?: string;
+    create_time?: string;
+    update_time?: string;
+}
 export interface LoginInfo {
     secret_id: string;
     cli_token: string;
     create_at: number;
     expire_in_sec: number;
+    cloudEnvInfo?: CloudEnvInfo | null;
+    userInfo?: CloudDevUserInfo | null;
 }

package/types/database.kit.d.ts

@@ -0,0 +1,54 @@
+import type { DatabaseClient } from "@vectorx/cloud-database-client";
+export type DbTable = {
+    schema?: string;
+    name: string;
+};
+export type DbColumn = {
+    name: string;
+    dataType?: string;
+    udtName?: string;
+    nullable?: boolean;
+    ordinalPosition?: number;
+    defaultValue?: string | null;
+};
+export type DbTablePreview = {
+    rows: Array<Record<string, any>>;
+    rowCount?: number;
+};
+export type DbPreviewOptions = {
+    limit?: number;
+    offset?: number;
+    orderBy?: string;
+    orderDirection?: "asc" | "desc";
+};
+export type SqlQuery = {
+    sql: string;
+    values?: any[];
+    readonly?: boolean;
+};
+export interface DatabaseRequestContext {
+    envId?: string;
+}
+export declare function getDatabaseClient(ctx?: DatabaseRequestContext): Promise<DatabaseClient>;
+export declare function listDatabaseTables(ctx?: DatabaseRequestContext, params?: {
+    schema?: string;
+}): Promise<{
+    tables: DbTable[];
+}>;
+export declare function getDatabaseTableColumns(ctx?: DatabaseRequestContext, params?: {
+    schema?: string;
+    table: string;
+}): Promise<{
+    columns: DbColumn[];
+}>;
+export declare function previewDatabaseTable(ctx?: DatabaseRequestContext, params?: {
+    schema?: string;
+    table: string;
+    options?: DbPreviewOptions;
+}): Promise<{
+    preview: DbTablePreview;
+}>;
+export declare function executeDatabaseSql(ctx?: DatabaseRequestContext, q?: SqlQuery): Promise<{
+    rows: any[];
+    rowCount?: number;
+}>;

package/types/env.kit.d.ts

@@ -0,0 +1,43 @@
+export interface CloudEnvironment {
+    cloud_env_name: string;
+    status: number;
+    cloud_env_id: string;
+    description?: string;
+    creator_id?: string;
+    create_time?: string;
+    update_time?: string;
+    env_variables?: unknown;
+}
+export interface CloudEnvironmentListData {
+    envs: CloudEnvironment[];
+}
+export interface CloudEnvironmentListResponse {
+    code: number;
+    msg: string;
+    success: boolean;
+    data: CloudEnvironmentListData;
+}
+export interface CloudEnvironmentCreateRequest {
+    cloud_env_name: string;
+    description?: string;
+}
+export interface CloudEnvironmentCreateResponse {
+    code: number;
+    msg: string;
+    success: boolean;
+    data: CloudEnvironment;
+}
+export interface CloudEnvironmentUpdateRequest {
+    cloud_env_id: string;
+    env_variables: string;
+}
+export interface CloudEnvironmentUpdateResponse {
+    code: number;
+    msg: string;
+    success: boolean;
+    data: CloudEnvironment;
+}
+export declare function getCloudEnvironments(cloudEnvId?: string): Promise<CloudEnvironment[]>;
+export declare function getCloudEnvironment(cloudEnvId: string): Promise<CloudEnvironment | null>;
+export declare function createCloudEnvironment(payload: CloudEnvironmentCreateRequest): Promise<CloudEnvironment>;
+export declare function updateCloudEnvironment(payload: CloudEnvironmentUpdateRequest): Promise<CloudEnvironment>;

package/types/fun.kit.d.ts

@@ -0,0 +1,63 @@
+export interface FunDevOptions {
+    workDir?: string;
+    uiPort?: number;
+    apiPort?: number;
+    watch?: boolean;
+    open?: boolean;
+    quiet?: boolean;
+    envId?: string;
+    mode?: "agent" | "fun";
+    deps?: {
+        startFunctionDebugger?: (opts: any) => Promise<{
+            uiUrl: string;
+            apiUrl: string;
+            wsUrl: string;
+            close: () => Promise<void>;
+        }>;
+    };
+}
+export interface FunDevRuntime {
+    workDir: string;
+    uiUrl: string;
+    apiUrl: string;
+    wsUrl: string;
+    ffUrl: string;
+    close: () => Promise<void>;
+}
+export type LogType = "info" | "success" | "error" | "warn";
+export interface LogCollector {
+    addLog(log: string, type?: LogType, loading?: boolean): void;
+}
+export interface FunDeployOptions {
+    envId: string;
+    workDir?: string;
+    includeNodeModules?: boolean;
+    desc?: string;
+    logCollector?: LogCollector;
+}
+export interface FunDeployResult {
+    success: boolean;
+    code: number;
+    msg?: string;
+    publisher?: string;
+}
+export interface PublishHistoryItem {
+    cloud_env_id: string;
+    desc: string;
+    resource_id: string;
+    committer_id: string;
+    committer_name: string;
+    committer_time: number;
+}
+export interface FunPublishHistoryOptions {
+    envId: string;
+    pageNo?: number;
+    pageSize?: number;
+}
+export interface FunPublishHistoryResult {
+    pkgList: PublishHistoryItem[];
+    total: number;
+}
+export declare function startFunDev(options?: FunDevOptions): Promise<FunDevRuntime>;
+export declare function deployFun(options: FunDeployOptions): Promise<FunDeployResult>;
+export declare function getPublishHistory(options: FunPublishHistoryOptions): Promise<FunPublishHistoryResult>;

package/types/index.d.ts

@@ -1,4 +1,8 @@
 export * from "./agent.kit";
+export * from "./fun.kit";
+export * from "./env.kit";
+export * from "./database.kit";
+export * from "./cloud-dev.kit";
 export { Uploader } from "./utils/cos-uploader";
 export * from "./container";
 export * from "./services";
@@ -10,4 +14,6 @@ export * from "./utils/tracker";
 export * from "./utils/port-finder";
 export * from "./utils/open-browser";
 export * from "./utils/output";
+export * from "./utils/table";
+export * from "./utils/fun-project-validator";
 export { TokenRequest, TokenResponse, UploadTempPermit, InternalTokenRequest, } from "./services/upload-service";

package/types/services/agent-service.d.ts

@@ -0,0 +1,11 @@
+import type { AgentDetail, AgentListItem, IAgentService } from "../container/types";
+export declare class AgentService implements IAgentService {
+    private readonly authService;
+    constructor();
+    private resolveAuthQuery;
+    getAgentList(params?: {
+        pageNo?: number;
+        pageSize?: number;
+    }): Promise<AgentListItem[]>;
+    getAgentInfoById(agentId: string): Promise<AgentDetail | null>;
+}

package/types/services/cloud-dev-service.d.ts

@@ -0,0 +1,23 @@
+import type { CloudDevUserInfo, ICloudDevService, LangfuseConfigResult } from "../container";
+export declare class CloudDevService implements ICloudDevService {
+    private readonly authService;
+    constructor();
+    private resolveAuthQuery;
+    private getCloudDevBaseUrl;
+    getLangfuseConfig(params?: {
+        secret_id?: string;
+        cli_token?: string;
+    }): Promise<LangfuseConfigResult>;
+    getCloudDevLLMBaseURL(params?: {
+        secret_id?: string;
+        cli_token?: string;
+    }): string;
+    getCloudDevAnthropicLLMBaseURL(params?: {
+        secret_id?: string;
+        cli_token?: string;
+    }): string;
+    getUserInfo(params?: {
+        secret_id?: string;
+        cli_token?: string;
+    }): Promise<CloudDevUserInfo>;
+}

package/types/services/cloud-env-service.d.ts

@@ -0,0 +1,10 @@
+import type { ICloudEnvService } from "../container";
+import type { CloudEnvironment, CloudEnvironmentCreateRequest, CloudEnvironmentUpdateRequest } from "../env.kit";
+export declare class CloudEnvService implements ICloudEnvService {
+    private readonly authService;
+    constructor();
+    getCloudEnvironments(cloudEnvId?: string): Promise<CloudEnvironment[]>;
+    getCloudEnvironment(cloudEnvId: string): Promise<CloudEnvironment | null>;
+    createCloudEnvironment(payload: CloudEnvironmentCreateRequest): Promise<CloudEnvironment>;
+    updateCloudEnvironment(payload: CloudEnvironmentUpdateRequest): Promise<CloudEnvironment>;
+}

package/types/services/database-service.d.ts

@@ -0,0 +1,33 @@
+import { type DatabaseClient } from "@vectorx/cloud-database-client";
+import type { IDatabaseService } from "../container/types";
+import type { DatabaseRequestContext, DbColumn, DbPreviewOptions, DbTable, DbTablePreview, SqlQuery } from "../database.kit";
+export declare class DatabaseService implements IDatabaseService {
+    private readonly authService;
+    private readonly clientCache;
+    private readonly mockRdsEndpointInfo;
+    constructor();
+    private pickDbEndpoint;
+    getOrCreateClient(ctx: DatabaseRequestContext): Promise<DatabaseClient>;
+    listTables(ctx: DatabaseRequestContext, params?: {
+        schema?: string;
+    }): Promise<{
+        tables: DbTable[];
+    }>;
+    getTableColumns(ctx: DatabaseRequestContext, params: {
+        schema?: string;
+        table: string;
+    }): Promise<{
+        columns: DbColumn[];
+    }>;
+    previewTable(ctx: DatabaseRequestContext, params: {
+        schema?: string;
+        table: string;
+        options?: DbPreviewOptions;
+    }): Promise<{
+        preview: DbTablePreview;
+    }>;
+    executeSql(ctx: DatabaseRequestContext, q: SqlQuery): Promise<{
+        rows: any[];
+        rowCount?: number;
+    }>;
+}

package/types/services/fun-service.d.ts

@@ -0,0 +1,23 @@
+import type { IFunService } from "../container";
+import type { FunDeployOptions, FunDeployResult, FunDevOptions, FunDevRuntime } from "../fun.kit";
+export declare class FunService implements IFunService {
+    private readonly authService;
+    constructor();
+    startFunDev(options?: FunDevOptions): Promise<FunDevRuntime>;
+    deploy(options: FunDeployOptions): Promise<FunDeployResult>;
+    getPublishHistory(options: {
+        envId: string;
+        pageNo?: number;
+        pageSize?: number;
+    }): Promise<{
+        pkgList: Array<{
+            cloud_env_id: string;
+            desc: string;
+            resource_id: string;
+            committer_id: string;
+            committer_name: string;
+            committer_time: number;
+        }>;
+        total: number;
+    }>;
+}

package/types/services/index.d.ts

@@ -1,2 +1,7 @@
 export * from "./auth-service";
 export * from "./upload-service";
+export * from "./cloud-dev-service";
+export * from "./cloud-env-service";
+export * from "./database-service";
+export * from "./fun-service";
+export * from "./agent-service";

package/types/utils/fun-project-validator.d.ts

@@ -0,0 +1,22 @@
+export interface FunValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings?: string[];
+}
+export interface FunctionConfig {
+    name: string;
+    directory: string;
+    source: string;
+    triggerPath: string;
+}
+export interface CloudFunctionConfig {
+    functionsRoot: string;
+    functions?: FunctionConfig[];
+}
+export declare class FunProjectValidator {
+    private workDir;
+    constructor(workDir: string);
+    validate(): Promise<FunValidationResult>;
+    private validateFunctionsConfig;
+    private validateDependencies;
+}

package/types/utils/table.d.ts

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