@vectorx/cloud-toolkit 0.1.0

package/types/container/types.d.ts

@@ -0,0 +1,19 @@
+import type { CheckStatusRequest, CheckStatusResponse } from "../services/auth-service";
+import type { BuildPreCheckResponse, IBuildPreCheckParams, IDeployParams } from "../services/upload-service";
+export interface IAuthService {
+    hasLogin(): boolean;
+    getLoginInfo(): Promise<LoginInfo | null>;
+    check(params: CheckStatusRequest): Promise<CheckStatusResponse>;
+    clearLoginInfo(): Promise<void>;
+}
+export interface IUploadService {
+    getCloudBaseSecretToken(): Promise<string>;
+    buildPreCheck(params: IBuildPreCheckParams): Promise<BuildPreCheckResponse>;
+    deploy(params: IDeployParams): Promise<any>;
+}
+export interface LoginInfo {
+    secret_id: string;
+    cli_token: string;
+    create_at: number;
+    expire_in_sec: number;
+}

package/types/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./agent.kit";
+export * from "./container";
+export * from "./services";
+export * from "./utils/config-merger";
+export * from "./utils/env-helper";
+export * from "./utils/helper";
+export * from "./utils/logger";
+export * from "./utils/tracker";
+export * from "./utils/port-finder";
+export * from "./utils/open-browser";
+export * from "./utils/output";
+export type { TokenRequest, TokenResponse, UploadTempPermit, InternalTokenRequest, } from "./services/upload-service";

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

@@ -0,0 +1,22 @@
+import type { IAuthService, LoginInfo } from "../container";
+export interface CheckStatusResponse {
+    code: number;
+    msg: string;
+    data: LoginInfo;
+}
+export type CheckStatusRequest = {
+    secret_id: string;
+    nonce: string;
+    cli_token: string;
+};
+export declare class AuthService implements IAuthService {
+    private readonly configDir;
+    private readonly configFile;
+    constructor();
+    getToken(secretId: string, secretKey: string, nonce: string): string;
+    hasLogin(): boolean;
+    saveLoginInfo(loginInfo: LoginInfo): Promise<void>;
+    getLoginInfo(): Promise<LoginInfo | null>;
+    check(params: CheckStatusRequest): Promise<CheckStatusResponse>;
+    clearLoginInfo(): Promise<void>;
+}

package/types/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./auth-service";
+export * from "./upload-service";

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

@@ -0,0 +1,95 @@
+import { type IUploadService } from "../container";
+export interface TokenRequest {
+    bizName: string;
+    scene: string;
+    fileCount: number;
+    fileFormat?: string;
+    persistentOps?: string;
+    persistentNotifyUrl?: string;
+}
+export interface TokenResponse {
+    uploadLimitPolicy?: {
+        fileTypes?: string[];
+        maxSize?: number;
+    };
+    uploadTempPermits: UploadTempPermit[];
+}
+export type GetToken = () => Promise<TokenResponse>;
+export interface IBuildPreCheckParams {
+    agent_id: string;
+    version: string;
+    desc: string;
+}
+export interface UploadTempPermit {
+    secretId?: string;
+    secretKey?: string;
+    token: string;
+    uploadAddr: string;
+    expireTime: number;
+    qos: number;
+    cloudType: number;
+    bucket: string;
+    region: string;
+    fileIds: string[];
+    masterCloudId: number;
+    uploadId: number;
+    cdnDomain?: string;
+}
+export interface TokenRequest {
+    bizName: string;
+    scene: string;
+    fileCount: number;
+    fileFormat?: string;
+    persistentOps?: string;
+    persistentNotifyUrl?: string;
+}
+export interface InternalTokenRequest extends TokenRequest {
+    subsystem: string;
+}
+export interface TokenResponse {
+    uploadLimitPolicy?: {
+        fileTypes?: string[];
+        maxSize?: number;
+    };
+    uploadTempPermits: UploadTempPermit[];
+}
+export interface InternalTokenRequest extends TokenRequest {
+    subsystem: string;
+}
+export interface BuildPreCheckResponse {
+    code: number;
+    success: boolean;
+    msg: string;
+}
+export interface IDeployResponse {
+    code: number;
+    success: boolean;
+    msg: string;
+}
+export interface IDeployParams {
+    targetPath: string;
+    agentId: string;
+    version: string;
+    desc: string;
+}
+export interface IUploadAgentPackageParams {
+    agent_id: string;
+    version: string;
+    desc: string;
+    file_url: string;
+    cloud_type: number;
+}
+export interface UploadAgentPackageResponse {
+    code: number;
+    success: boolean;
+    msg: string;
+}
+export declare class UploadService implements IUploadService {
+    private readonly authService;
+    constructor();
+    getCloudBaseSecretToken(): Promise<string>;
+    getToken(): Promise<TokenResponse>;
+    buildPreCheck(params: IBuildPreCheckParams): Promise<BuildPreCheckResponse>;
+    deploy(params: IDeployParams): Promise<IDeployResponse>;
+    private uploadAgentPackage;
+}

package/types/utils/config-merger.d.ts

@@ -0,0 +1 @@
+export declare function mergeProjectConfigs(workDir: string): void;

package/types/utils/cos-uploader.d.ts

@@ -0,0 +1,41 @@
+import COS, { type UploadBody } from "cos-nodejs-sdk-v5";
+import type { GetToken } from "../services/upload-service";
+interface IFileInfo {
+    name: string;
+    size: number;
+    type: string;
+}
+export interface UploadResponse extends COS.UploadFileResult {
+    bizName: string;
+    scene: string;
+    cloudType: number;
+    cdnDomain?: string;
+    fileId: string;
+    previewUrl?: string;
+    staticUrl?: string;
+    url?: string;
+    useCache?: boolean;
+    sliceSize?: number;
+    isSlice?: boolean;
+    tokenFail?: boolean;
+}
+export declare class Uploader {
+    bizName: string;
+    scene: string;
+    getToken: GetToken;
+    enableResume?: boolean;
+    constructor(args: {
+        bizName: string;
+        scene: string;
+        getToken: GetToken;
+        enableResume?: boolean;
+    });
+    private getPermit;
+    post(options: Omit<COS.UploadFileParams, "Bucket" | "Region" | "Key"> & {
+        Body: UploadBody;
+        fileInfo: IFileInfo;
+        fileFormat?: string;
+        onInstanceCreated?: (instance: COS) => void;
+    }): Promise<UploadResponse>;
+}
+export {};

package/types/utils/env-helper.d.ts

@@ -0,0 +1 @@
+export declare const isIDE: boolean;

package/types/utils/helper.d.ts

@@ -0,0 +1,6 @@
+export declare const getFixedFormatTime: (format: string, timeDistance?: number) => string;
+export declare function getNonce(): string;
+export declare function getMd5(str: string): string;
+export declare function guid(): string;
+export declare function retry<T>(fn: () => Promise<T>, maxRetries?: number, delay?: number): Promise<T>;
+export declare const toHump: (str: string) => string;

package/types/utils/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;
+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/logger.d.ts

@@ -0,0 +1,24 @@
+import ora, { type Ora } from "ora";
+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>;
+    spinner(text: string, color?: ora.Color): Ora;
+}
+export declare const logger: Logger;

package/types/utils/open-browser.d.ts

@@ -0,0 +1,2 @@
+declare const openBrowser: (host: string, port: number) => boolean;
+export { openBrowser };

package/types/utils/output.d.ts

@@ -0,0 +1 @@
+export declare const outputHelpInfo: () => void;

package/types/utils/port-finder.d.ts

@@ -0,0 +1,2 @@
+export declare function findAvailablePort(startPort: number): Promise<number>;
+export declare function isPortAvailable(port: number): Promise<boolean>;

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

@@ -0,0 +1,10 @@
+import type { IUploadOptions } from "../agent.kit";
+export declare class ProjectValidator {
+    private workDir;
+    private uploadInfo;
+    constructor(workDir: string, uploadInfo: IUploadOptions);
+    validate(): Promise<{
+        valid: boolean;
+        errors: string[];
+    }>;
+}

package/types/utils/request.d.ts

@@ -0,0 +1,25 @@
+export interface RequestOptions {
+    method?: "GET" | "POST" | "PUT" | "DELETE";
+    url: string;
+    data?: {
+        params?: any;
+        body?: any;
+        withCredentials?: boolean;
+        query?: any;
+    };
+    headers?: Record<string, string>;
+}
+export interface RequestResponse<T> {
+    status: number;
+    data: T;
+    headers: any;
+}
+export declare class Request {
+    fetch<T = any>(options: RequestOptions): Promise<RequestResponse<T>>;
+    handleHttpStatus<T>(response: RequestResponse<T>): T;
+    handleCode<T extends {
+        code: number;
+        msg: string;
+    }>(data: T): T;
+}
+export declare const request: Request;

package/types/utils/tracker/device.d.ts

@@ -0,0 +1,4 @@
+import type { IDeviceInfo, IDeviceUA } from "./tracker";
+export declare function getDeviceInfo(): IDeviceInfo;
+export declare function deviceUA(): IDeviceUA;
+export declare function machineId(): string;

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

@@ -0,0 +1,27 @@
+import type { IBase } from "./tracker";
+interface ISequence {
+    context_sdkSeqId: number;
+    context_sdkSessionId: string;
+    context_pageSessionId: string;
+    clientTime: number;
+}
+interface IReqItem {
+    suquence: ISequence;
+    measurement_name: string;
+    measurement_data: Record<string, any>;
+}
+export declare class APM {
+    private reportQueue;
+    private allowReport;
+    private eventSeq;
+    private context;
+    private baseData;
+    setContext(userId: string, base?: IBase): void;
+    private startReport;
+    private getSequence;
+    private _request;
+    private bactchReport;
+    private timer;
+    report(measurement_name: string, measurement_data?: IReqItem["measurement_data"]): void;
+}
+export {};

package/types/utils/tracker/tracker.d.ts

@@ -0,0 +1,22 @@
+export interface IDeviceInfo {
+    os_platform: string;
+    os_arch: string;
+    cpu_speed: number;
+    cpu_model: string;
+    machine_memory: number;
+    os_version: string;
+}
+export interface IDeviceUA {
+    login_user?: string;
+    node_version: string;
+}
+export interface IBase {
+    app_id?: string;
+    app_name?: string;
+    third_name?: string;
+    page_key?: string;
+    base_version?: string;
+    app_env?: number;
+    app_type?: number;
+    bundle_version?: string;
+}