@skillbuilder/minitool-core 0.0.0-beta-20261027053041051

package/lib/utils/tracker/cli-apm.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI_MEASUREMENT_NAME = void 0;
+exports.initCliApm = initCliApm;
+exports.setCliApmCurrentCommand = setCliApmCurrentCommand;
+exports.createCliCommandTracker = createCliCommandTracker;
+exports.reportCliException = reportCliException;
+exports.reportCliHttpError = reportCliHttpError;
+exports.flushCliApm = flushCliApm;
+const node_crypto_1 = require("node:crypto");
+/** CLI 通用埋点；不依赖小工具业务服务，也不读取本地凭据。 */
+exports.CLI_MEASUREMENT_NAME = "redminitool_cli_usage";
+let transport;
+let cliVersion = "unknown";
+let currentCmdPath;
+let sequence = 0;
+let sessionId = (0, node_crypto_1.randomUUID)();
+const pending = new Set();
+const controllers = new Set();
+function createHttpTransport(endpoint) {
+    let url;
+    try {
+        url = new URL(endpoint);
+    }
+    catch {
+        return undefined;
+    }
+    // 远端上报仅允许 HTTPS；本机 HTTP 用于联调和测试。
+    if (url.protocol !== "https:" &&
+        !(url.protocol === "http:" && ["localhost", "127.0.0.1"].includes(url.hostname))) {
+        return undefined;
+    }
+    return {
+        async report(event) {
+            const controller = new AbortController();
+            controllers.add(controller);
+            const timer = setTimeout(() => controller.abort(), 1500);
+            try {
+                const response = await fetch(url, {
+                    method: "POST",
+                    headers: { "content-type": "application/json", batch: "true", "biz-type": "apm_fe" },
+                    body: JSON.stringify([event]),
+                    signal: controller.signal,
+                });
+                if (!response.ok)
+                    throw new Error(`APM HTTP ${response.status}`);
+            }
+            finally {
+                clearTimeout(timer);
+                controllers.delete(controller);
+            }
+        },
+    };
+}
+function initCliApm(options = {}) {
+    cliVersion = options.cliVersion || "unknown";
+    sessionId = (0, node_crypto_1.randomUUID)();
+    sequence = 0;
+    currentCmdPath = undefined;
+    transport =
+        options.transport ||
+            createHttpTransport(options.endpoint || process.env.REDMINITOOL_APM_ENDPOINT || "");
+}
+function setCliApmCurrentCommand(cmdPath) {
+    currentCmdPath = cmdPath;
+}
+function safeError(err) {
+    const error = err && typeof err === "object" ? err : {};
+    const message = typeof error.message === "string" ? error.message.toLowerCase() : "";
+    const rawCode = error.code ?? error.statusCode ?? error.status;
+    const errorCode = typeof rawCode === "number" && Number.isInteger(rawCode)
+        ? rawCode
+        : typeof rawCode === "string" && /^[A-Z][A-Z0-9_]{0,63}$/.test(rawCode)
+            ? rawCode
+            : undefined;
+    let errorType = "unknown";
+    if (typeof errorCode === "number" && errorCode >= 400)
+        errorType = "http";
+    if (/http|request|fetch/.test(message))
+        errorType = "http";
+    if (/token|login|auth|secret/.test(message))
+        errorType = "auth";
+    if (/invalid|参数|校验/.test(message))
+        errorType = "validation";
+    // 不上报 message、stack 或任意服务端响应，避免 Secret/Token 从异常文本泄露。
+    return { error_type: errorType, ...(errorCode !== undefined ? { error_code: errorCode } : {}) };
+}
+function report(data) {
+    const target = transport;
+    if (!target)
+        return;
+    const event = {
+        context_nameTracker: "nodeT",
+        context_platform: process.platform,
+        context_appVersion: cliVersion,
+        context_matchedPath: "cli",
+        context_sdkSessionId: sessionId,
+        context_sdkSeqId: ++sequence,
+        clientTime: Date.now(),
+        measurement_name: exports.CLI_MEASUREMENT_NAME,
+        measurement_data: {
+            ...data,
+            cli_version: cliVersion,
+            node_major: Number(process.versions.node.split(".")[0]),
+            is_ci: process.env.CI ? 1 : 0,
+        },
+    };
+    let task;
+    task = Promise.resolve()
+        .then(() => target.report(event))
+        .then(() => undefined, () => undefined)
+        .finally(() => pending.delete(task));
+    pending.add(task);
+}
+function createCliCommandTracker(meta) {
+    setCliApmCurrentCommand(meta.cmd_path);
+    const base = {
+        event: "command",
+        cmd_path: meta.cmd_path,
+        ...(meta.cmd_root ? { cmd_root: meta.cmd_root } : {}),
+        ...(typeof meta.params_count === "number" ? { params_count: meta.params_count } : {}),
+        // 仅上报选项名称；认证参数名称也排除，永不传递参数值。
+        ...(meta.options_keys
+            ? {
+                options_keys: JSON.stringify(meta.options_keys.filter((key) => !/secret|token|password|credential|auth/i.test(key))),
+            }
+            : {}),
+    };
+    return {
+        reportSuccess(durationMs) {
+            report({ ...base, status: 1, duration: durationMs });
+            setCliApmCurrentCommand(undefined);
+        },
+        reportFail(durationMs, err) {
+            report({
+                ...base,
+                status: 0,
+                duration: durationMs,
+                ...safeError(err),
+            });
+            setCliApmCurrentCommand(undefined);
+        },
+    };
+}
+function reportCliException(source, err) {
+    report({
+        event: "exception",
+        source,
+        ...(currentCmdPath ? { cmd_path: currentCmdPath } : {}),
+        ...safeError(err),
+    });
+}
+function reportCliHttpError(meta, err) {
+    let host;
+    try {
+        if (meta.url)
+            host = new URL(meta.url).host;
+    }
+    catch {
+        /* 无效 URL 不影响业务 */
+    }
+    report({
+        event: "http_error",
+        ...(meta.method ? { method: meta.method } : {}),
+        ...(host ? { host } : {}),
+        ...(typeof meta.status_code === "number" ? { status_code: meta.status_code } : {}),
+        ...(currentCmdPath ? { cmd_path: currentCmdPath } : {}),
+        ...(err ? safeError(err) : {}),
+    });
+}
+/** CLI 退出前最多等待一小段时间，超时后取消请求；上报失败永不影响命令结果。 */
+async function flushCliApm(timeoutMs = 350) {
+    if (!pending.size)
+        return;
+    let timer;
+    await Promise.race([
+        Promise.allSettled([...pending]),
+        new Promise((resolve) => {
+            timer = setTimeout(() => {
+                for (const controller of controllers)
+                    controller.abort();
+                resolve();
+            }, timeoutMs);
+        }),
+    ]);
+    if (timer)
+        clearTimeout(timer);
+}

package/lib/utils/tracker/device.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDeviceInfo = getDeviceInfo;
+exports.deviceUA = deviceUA;
+exports.machineId = machineId;
+const node_os_1 = __importDefault(require("node:os"));
+/** 本地诊断信息；CLI APM 不会自动采集或发送这些字段。 */
+function getDeviceInfo() {
+    const cpu = node_os_1.default.cpus()[0];
+    return {
+        os_platform: process.platform,
+        os_arch: process.arch,
+        cpu_speed: cpu?.speed ?? 0,
+        cpu_model: cpu?.model ?? "",
+        machine_memory: Math.round(node_os_1.default.totalmem() / 1024 / 1024),
+        os_version: node_os_1.default.release(),
+    };
+}
+function deviceUA() {
+    return { node_version: process.version };
+}
+/**
+ * 旧版会读取硬件 UUID 并写 ~/.rcb/.device.json；该持久设备标识未获隐私评审，不再生成。
+ */
+function machineId() {
+    throw new Error("持久设备标识已禁用；需要先完成隐私评审");
+}

package/lib/utils/tracker/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./apm"), exports);
+__exportStar(require("./ai-apm"), exports);
+__exportStar(require("./cli-apm"), exports);
+__exportStar(require("./device"), exports);
+__exportStar(require("./tracker"), exports);

package/lib/utils/tracker/tracker.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@skillbuilder/minitool-core",
+  "version": "0.0.0-beta-20261027053041051",
+  "description": "小红书小工具 DI/IoC 业务核心与上传能力",
+  "main": "lib/index.js",
+  "types": "types/index.d.ts",
+  "files": [
+    "lib",
+    "types",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "chalk": "^2.4.2",
+    "cli-table3": "^0.5.1",
+    "cos-nodejs-sdk-v5": "2.x",
+    "dayjs": "^1.11.13",
+    "inversify": "^7.11.0",
+    "log-symbols": "^3.0.0",
+    "open": "^7.4.2",
+    "ora": "^4.0.2",
+    "reflect-metadata": "0.2.2",
+    "terminal-link": "^2.1.1",
+    "zod": "4.3.5",
+    "jszip": "^3.10.1",
+    "@skillbuilder/minitool-cli-auth": "0.0.0-beta-20261027053041051",
+    "@skillbuilder/endpoints": "0.0.0-beta-20261027053041051"
+  },
+  "license": "ISC"
+}

package/types/di/index.d.ts

@@ -0,0 +1,3 @@
+export { ContainerModule } from "inversify";
+export * from "./modules";
+export * from "./tokens";

package/types/di/modules.d.ts

@@ -0,0 +1,9 @@
+import type { AccessTokenProvider } from "@skillbuilder/minitool-cli-auth";
+import { ContainerModule } from "inversify";
+import { type MiniToolApiOptions } from "../services/minitool-api";
+export interface MinitoolModuleOptions {
+    auth: AccessTokenProvider;
+    api: MiniToolApiOptions;
+}
+/** MiniTool Core 显式注册业务、传输及其窄依赖。 */
+export declare function createMinitoolModule(options: MinitoolModuleOptions): ContainerModule;

package/types/di/tokens.d.ts

@@ -0,0 +1,9 @@
+/** MiniTool Runtime 服务与依赖标识。 */
+export declare const MINITOOL_TOKENS: Readonly<{
+    api: symbol;
+    apiOptions: symbol;
+    auth: symbol;
+    miniTool: symbol;
+    cosClientFactory: symbol;
+    upload: symbol;
+}>;

package/types/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./di";
+export * from "./runtime";
+export * from "./services";
+export * from "./utils/tracker";
+export * from "./utils/helper";
+export * from "./utils/loading";
+export * from "./utils/logger";
+export * from "./utils/open-browser";
+export * from "./utils/output";
+export * from "./utils/port-finder";
+export * from "./utils/project-validator";
+export * from "./utils/request";
+export * from "./utils/table";
+export type { CosClientFactory, CosUploadClient } from "./utils/cos-uploader";

package/types/runtime.d.ts

@@ -0,0 +1,24 @@
+import type { AccessTokenProvider } from "@skillbuilder/minitool-cli-auth";
+import { type ContainerModule } from "inversify";
+import type { MiniToolApiOptions } from "./services/minitool-api";
+import type { IMiniToolService } from "./services/minitool-service";
+import type { IUploadService } from "./services/upload-service";
+export interface MinitoolServiceGraph {
+    readonly upload: IUploadService;
+    readonly miniTools: IMiniToolService;
+}
+export interface MinitoolRuntime extends MinitoolServiceGraph {
+    readonly isDisposed: boolean;
+    dispose(): Promise<void>;
+}
+export interface CreateMinitoolCoreOptions {
+    accessTokens: AccessTokenProvider;
+    api?: MiniToolApiOptions;
+    /**
+     * 在默认模块之后加载。测试可使用公共 Token + rebindSync 替换服务，
+     * 业务扩展也必须以显式 ContainerModule 接入，禁止目录扫描。
+     */
+    modules?: readonly ContainerModule[];
+}
+/** 组装相互隔离、可释放的业务 Runtime；Container 不向调用方暴露。 */
+export declare function createMinitoolCore(options: CreateMinitoolCoreOptions): MinitoolRuntime;

package/types/services/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./minitool-service";
+export * from "./upload-service";
+export * from "./minitool-api";

package/types/services/minitool-api.d.ts

@@ -0,0 +1,30 @@
+import "reflect-metadata";
+import type { AccessTokenProvider } from "@skillbuilder/minitool-cli-auth";
+export declare const MINITOOL_ROUTES: Readonly<{
+    readonly config: readonly ["GET", "/api/sns/v2/creator/red_app/third/config"];
+    readonly list: readonly ["GET", "/api/sns/v2/creator/red_app/third/list"];
+    readonly status: readonly ["GET", "/api/sns/v2/creator/red_app/third/detail"];
+    readonly history: readonly ["GET", "/api/sns/v2/creator/red_app/third/history_version"];
+    readonly submit: readonly ["POST", "/api/sns/v2/creator/red_app/third/save"];
+    readonly edit: readonly ["POST", "/api/sns/v2/creator/red_app/third/base/save"];
+    readonly preview: readonly ["POST", "/api/sns/v2/creator/red_app/third/preview_code"];
+    readonly permit: readonly ["GET", "/api/sns/v2/red_skill/upload/permit"];
+}>;
+export type MiniToolOperation = keyof typeof MINITOOL_ROUTES;
+export interface MiniToolApiOptions {
+    apiBaseUrl: string;
+    request?: typeof fetch;
+}
+export interface IMiniToolApi {
+    call(operation: MiniToolOperation, payload: object): Promise<Record<string, unknown>>;
+}
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/** 仅允许 HTTPS 或本机测试地址，且禁止凭据重定向到其他 host。 */
+export declare function validateApiBaseUrl(value: string): string;
+export declare class MiniToolHttpClient implements IMiniToolApi {
+    private readonly accessTokens;
+    private readonly baseUrl;
+    private readonly request;
+    constructor(accessTokens: AccessTokenProvider, options: MiniToolApiOptions);
+    call(operation: MiniToolOperation, payload: object): Promise<Record<string, unknown>>;
+}

package/types/services/minitool-contract.d.ts

@@ -0,0 +1,103 @@
+import { z } from "zod";
+export declare const miniToolSourceSchema: z.ZodObject<{
+    source: z.ZodString;
+}, z.core.$strict>;
+export declare const miniToolListSchema: z.ZodObject<{
+    pageNum: z.ZodDefault<z.ZodNumber>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+    source: z.ZodString;
+}, z.core.$strict>;
+export declare const miniToolDetailSchema: z.ZodObject<{
+    appId: z.ZodString;
+    source: z.ZodString;
+}, z.core.$strict>;
+export declare const miniToolPreviewSchema: z.ZodObject<{
+    pkgFileId: z.ZodString;
+    md5: z.ZodString;
+    appName: z.ZodOptional<z.ZodString>;
+    iconFileId: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    source: z.ZodString;
+}, z.core.$strict>;
+export declare const miniToolReviewSchema: z.ZodObject<{
+    appId: z.ZodOptional<z.ZodString>;
+    appName: z.ZodString;
+    slogan: z.ZodString;
+    iconFileId: z.ZodString;
+    coverFileId: z.ZodString;
+    version: z.ZodString;
+    pkgFileId: z.ZodString;
+    md5: z.ZodString;
+    categories: z.ZodArray<z.ZodString>;
+    authorizations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    source: z.ZodString;
+}, z.core.$strict>;
+export declare const miniToolEditSchema: z.ZodObject<{
+    appId: z.ZodString;
+    appName: z.ZodString;
+    slogan: z.ZodString;
+    iconFileId: z.ZodString;
+    coverFileId: z.ZodOptional<z.ZodString>;
+    source: z.ZodString;
+}, z.core.$strict>;
+export declare const miniToolUploadSchema: z.ZodObject<{
+    filePath: z.ZodString;
+    type: z.ZodEnum<{
+        pkg: "pkg";
+        image: "image";
+    }>;
+    expectedSha256: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type MiniToolSourceInput = z.input<typeof miniToolSourceSchema>;
+export type MiniToolListInput = z.input<typeof miniToolListSchema>;
+export type MiniToolDetailInput = z.input<typeof miniToolDetailSchema>;
+export type MiniToolPreviewInput = z.input<typeof miniToolPreviewSchema>;
+export type MiniToolReviewInput = z.input<typeof miniToolReviewSchema>;
+export type MiniToolEditInput = z.input<typeof miniToolEditSchema>;
+export type UploadInput = z.input<typeof miniToolUploadSchema>;
+export interface MiniToolSummary extends Record<string, unknown> {
+    appId: string;
+    appName?: string;
+    version?: string;
+    status?: number;
+    statusText?: string;
+    auditStatus?: number;
+    auditStatusText?: string;
+}
+export interface MiniToolPage {
+    apps: MiniToolSummary[];
+    total: number;
+    pageNum: number;
+    pageSize: number;
+}
+export interface MiniToolConfig extends Record<string, unknown> {
+    categories: {
+        code: string;
+        name?: string;
+    }[];
+    authorizations: {
+        code: string;
+        name?: string;
+    }[];
+}
+export interface MiniToolHistory extends Record<string, unknown> {
+    versions: Record<string, unknown>[];
+}
+export interface MiniToolPreviewResult extends Record<string, unknown> {
+    previewUrl: string;
+}
+export interface MiniToolReviewResult extends Record<string, unknown> {
+    appId: string;
+}
+export interface MiniToolUploadResult {
+    fileId: string;
+    md5: string;
+    sha256: string;
+    size: number;
+    type: "pkg" | "image";
+}
+export declare function parseMiniToolInput<T>(schema: z.ZodType<T>, value: unknown): T;
+export declare class MiniToolError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}

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

@@ -0,0 +1,29 @@
+import "reflect-metadata";
+import type { IMiniToolApi } from "./minitool-api";
+import { type MiniToolConfig, type MiniToolDetailInput, type MiniToolEditInput, type MiniToolHistory, type MiniToolListInput, type MiniToolPage, type MiniToolPreviewInput, type MiniToolPreviewResult, type MiniToolReviewInput, type MiniToolReviewResult, type MiniToolSourceInput, type MiniToolSummary, type MiniToolUploadResult, type UploadInput } from "./minitool-contract";
+import { type IUploadService } from "./upload-service";
+export * from "./minitool-contract";
+export interface IMiniToolService {
+    getConfig(input: MiniToolSourceInput): Promise<MiniToolConfig>;
+    list(input: MiniToolListInput): Promise<MiniToolPage>;
+    getStatus(input: MiniToolDetailInput): Promise<MiniToolSummary>;
+    getHistory(input: MiniToolDetailInput): Promise<MiniToolHistory>;
+    upload(input: UploadInput): Promise<MiniToolUploadResult>;
+    createPreview(input: MiniToolPreviewInput): Promise<MiniToolPreviewResult>;
+    submitReview(input: MiniToolReviewInput): Promise<MiniToolReviewResult>;
+    edit(input: MiniToolEditInput): Promise<MiniToolReviewResult>;
+}
+/** 编排业务校验、平台接口与文件传输；不读取凭据文件。 */
+export declare class MiniToolService implements IMiniToolService {
+    private readonly api;
+    private readonly uploadService;
+    constructor(api: IMiniToolApi, uploadService: IUploadService);
+    getConfig(input: MiniToolSourceInput): Promise<MiniToolConfig>;
+    list(input: MiniToolListInput): Promise<MiniToolPage>;
+    getStatus(input: MiniToolDetailInput): Promise<MiniToolSummary>;
+    getHistory(input: MiniToolDetailInput): Promise<MiniToolHistory>;
+    upload(input: UploadInput): Promise<MiniToolUploadResult>;
+    createPreview(input: MiniToolPreviewInput): Promise<MiniToolPreviewResult>;
+    submitReview(input: MiniToolReviewInput): Promise<MiniToolReviewResult>;
+    edit(input: MiniToolEditInput): Promise<MiniToolReviewResult>;
+}

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

@@ -0,0 +1,48 @@
+import "reflect-metadata";
+import { type CosClientFactory } from "../utils/cos-uploader";
+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 UploadPermitResponse {
+    uploadLimitPolicy?: {
+        fileTypes?: string[];
+        maxSize?: number;
+    };
+    uploadTempPermits: UploadTempPermit[];
+}
+export type GetUploadPermit = () => Promise<UploadPermitResponse>;
+export interface ArtifactUploadInput {
+    filePath: string;
+    bizName: string;
+    scene: string;
+    contentType?: string;
+    getPermit(): Promise<UploadPermitResponse>;
+}
+export interface UploadedArtifact {
+    fileId: string;
+    url?: string;
+    cloudType: number;
+}
+export interface IUploadService {
+    upload(input: ArtifactUploadInput): Promise<UploadedArtifact>;
+}
+/** 与具体业务无关的上传服务：获取临时凭证并把本地文件传输到 COS。 */
+export declare class UploadService implements IUploadService {
+    private readonly createCos;
+    constructor(createCos: CosClientFactory);
+    upload(input: ArtifactUploadInput): Promise<UploadedArtifact>;
+}
+/** ROS 上传授权允许 snake_case 与 camelCase；对外只返回文件标识。 */
+export declare function normalizeUploadPermit(data: Record<string, unknown>): UploadPermitResponse;

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

@@ -0,0 +1,6 @@
+/**
+ * 历史 Agent/云函数配置工具，当前小工具 CLI 不调用。
+ * 合并 project.config.json 和 agent-cloudbase-functions.json 配置。
+ * 将 project.config.json 中的白名单属性（agentId、version）合并到 agent-cloudbase-functions.json
+ */
+export declare function mergeProjectConfigs(workDir: string): void;

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

@@ -0,0 +1,45 @@
+import COS, { type UploadBody } from "cos-nodejs-sdk-v5";
+import type { GetUploadPermit } from "../services/upload-service";
+export type CosUploadClient = Pick<COS, "uploadFile">;
+export type CosClientFactory = (options: COS.COSOptions) => CosUploadClient;
+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: GetUploadPermit;
+    enableResume?: boolean;
+    private readonly createCos;
+    constructor(args: {
+        bizName: string;
+        scene: string;
+        getToken: GetUploadPermit;
+        enableResume?: boolean;
+        createCos?: CosClientFactory;
+    });
+    private getPermit;
+    post(options: Omit<COS.UploadFileParams, "Bucket" | "Region" | "Key"> & {
+        Body: UploadBody;
+        fileInfo: IFileInfo;
+        fileFormat?: string;
+        onInstanceCreated?: (instance: CosUploadClient) => 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,8 @@
+export { toHump } from "./to-hump";
+export declare function getFixedFormatTime(format: string, timeDistance?: number): string;
+/** 安全随机数；可用于请求 nonce，不使用 Math.random。 */
+export declare function getNonce(): string;
+/** 仅供非安全场景的兼容性摘要，不应用于签名或密码存储。 */
+export declare function getMd5(value: string): string;
+export declare function guid(): string;
+export declare function retry<T>(fn: () => Promise<T>, maxRetries?: number, delay?: number): Promise<T>;

package/types/utils/loading.d.ts

@@ -0,0 +1,15 @@
+export declare class Loading {
+    private readonly spinner;
+    set text(value: string);
+    start(text: string): void;
+    stop(): void;
+    succeed(text: string): void;
+    fail(text: string): void;
+}
+export declare function loadingFactory(): Loading;
+export interface ILoadingOptions {
+    startTip?: string;
+    successTip?: string;
+    failTip?: string;
+}
+export declare function execWithLoading<T>(task: (flush: (text: string) => void) => Promise<T>, options?: ILoadingOptions): Promise<T>;