@vectorx/cloud-toolkit 0.5.0 → 1.0.0

package/lib/services/fun-service.js

@@ -0,0 +1,378 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunService = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const archiver_1 = __importDefault(require("archiver"));
+const inversify_1 = require("inversify");
+const agent_kit_1 = require("../agent.kit");
+const config_1 = require("../config");
+const container_1 = require("../container");
+const cos_uploader_1 = require("../utils/cos-uploader");
+const env_helper_1 = require("../utils/env-helper");
+const logger_1 = require("../utils/logger");
+const port_finder_1 = require("../utils/port-finder");
+const request_1 = require("../utils/request");
+const DEFAULT_DEBUGGER_API_PORT = 9230;
+let FunService = class FunService {
+    constructor() {
+        this.authService = container_1.container.get(container_1.SERVICE_IDENTIFIERS.AuthService);
+    }
+    startFunDev() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            var _a;
+            const { workDir = process.cwd(), uiPort, apiPort, watch = true, open = false, quiet = false, envId, mode = "fun", } = options;
+            const absWorkDir = path_1.default.isAbsolute(workDir) ? workDir : path_1.default.resolve(process.cwd(), workDir);
+            if (!fs_1.default.existsSync(absWorkDir)) {
+                throw new Error(`目录不存在: ${absWorkDir}`);
+            }
+            let ffPort;
+            if (apiPort) {
+                const candidate = apiPort + 1;
+                if (yield (0, port_finder_1.isPortAvailable)(candidate)) {
+                    ffPort = candidate;
+                }
+                else {
+                    ffPort = yield (0, port_finder_1.findAvailablePort)(apiPort + 2);
+                }
+            }
+            else {
+                ffPort = yield (0, port_finder_1.findAvailablePort)(9000);
+            }
+            const ffUrl = `http://localhost:${ffPort}`;
+            const logCollector = [];
+            let logBroadcastFn = null;
+            let startFunctionDebugger = (_a = options === null || options === void 0 ? void 0 : options.deps) === null || _a === void 0 ? void 0 : _a.startFunctionDebugger;
+            if (!startFunctionDebugger) {
+                try {
+                    ({ startFunctionDebugger } = require("@vectorx/function-debugger/lib/App"));
+                }
+                catch (err) {
+                    const msg = (err === null || err === void 0 ? void 0 : err.message) || String(err);
+                    const isMissing = (err === null || err === void 0 ? void 0 : err.code) === "MODULE_NOT_FOUND" &&
+                        (msg.includes("@vectorx/function-debugger") || msg.includes("function-debugger"));
+                    if (!isMissing) {
+                        throw err;
+                    }
+                    throw new Error([
+                        "未检测到可选依赖 @vectorx/function-debugger，无法启动本地调试器。",
+                        "如在 CLI 中使用，请升级/使用最新的 rcb（CLI 会自动注入该依赖）。",
+                        "如需在当前项目手动启用该能力，请安装：",
+                        "  pnpm add @vectorx/function-debugger",
+                        "或在 monorepo 根目录安装：",
+                        "  pnpm add -w @vectorx/function-debugger",
+                    ].join("\n"));
+                }
+            }
+            let debuggerApiPort;
+            if (typeof apiPort === "number" && apiPort > 0) {
+                debuggerApiPort = apiPort;
+            }
+            else {
+                debuggerApiPort = yield (0, port_finder_1.findAvailablePort)(DEFAULT_DEBUGGER_API_PORT);
+            }
+            yield (0, agent_kit_1.startRcbFramework)(absWorkDir, ffPort, Boolean(watch), undefined, { mode }, (log) => {
+                if (logBroadcastFn) {
+                    logBroadcastFn(log);
+                }
+                else {
+                    logCollector.push(log);
+                    if (logCollector.length > 1000) {
+                        logCollector.shift();
+                    }
+                }
+            });
+            const runtime = yield startFunctionDebugger({
+                source: absWorkDir,
+                uiPort,
+                apiPort: debuggerApiPort,
+                watch,
+                quiet,
+                openBrowser: open,
+                envId,
+                targetBaseUrl: ffUrl,
+                onLogBroadcastReady: (broadcastFn) => {
+                    logBroadcastFn = broadcastFn;
+                    logCollector.forEach((log) => {
+                        broadcastFn(log);
+                    });
+                    logCollector.length = 0;
+                },
+            });
+            return {
+                workDir: absWorkDir,
+                uiUrl: runtime.uiUrl,
+                apiUrl: runtime.apiUrl,
+                wsUrl: runtime.wsUrl,
+                ffUrl,
+                close: runtime.close,
+            };
+        });
+    }
+    deploy(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const { envId, workDir = process.cwd(), includeNodeModules = true, desc, logCollector } = options;
+            const log = (message_1, ...args_1) => __awaiter(this, [message_1, ...args_1], void 0, function* (message, type = "info", loading = false) {
+                if (logCollector) {
+                    yield logCollector.addLog(message, type, loading);
+                }
+                else {
+                    switch (type) {
+                        case "success":
+                            console.log(`✓ ${message}`);
+                            break;
+                        case "error":
+                            console.error(`✗ ${message}`);
+                            break;
+                        case "warn":
+                            console.warn(`⚠ ${message}`);
+                            break;
+                        default:
+                            console.log(message);
+                    }
+                }
+            });
+            yield log("初始化检查...", "info");
+            const absWorkDir = path_1.default.isAbsolute(workDir) ? workDir : path_1.default.resolve(process.cwd(), workDir);
+            if (!fs_1.default.existsSync(absWorkDir)) {
+                const errorMsg = `目录不存在: ${absWorkDir}`;
+                yield log(`错误: ${errorMsg}`, "error");
+                throw new Error(errorMsg);
+            }
+            yield log(`工作目录: ${absWorkDir}`, "info");
+            yield log("检查登录状态...", "info");
+            const loginInfo = yield this.authService.getLoginInfo();
+            if (!loginInfo) {
+                const errorMsg = "未检测到登录信息，请先执行 rcb login。";
+                yield log(`错误: ${errorMsg}`, "error");
+                throw new Error(errorMsg);
+            }
+            yield log("登录状态检查通过", "success");
+            const baseDesc = desc || `函数环境(${envId}) 代码包部署`;
+            yield log(`部署描述: ${baseDesc}`, "info");
+            yield log("开始预检...", "info");
+            yield log(`环境 ID: ${envId}`, "info");
+            const preCheckResponse = yield request_1.request.fetch({
+                method: "POST",
+                url: `${(0, config_1.getBaseUrl)()}/api/eros/mp/red/code/cloud_env_pkg/develop/upload_pre_check`,
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                data: {
+                    query: {
+                        secret_id: loginInfo.secret_id,
+                        cli_token: loginInfo.cli_token,
+                    },
+                    body: {
+                        cloud_env_id: envId,
+                        desc: baseDesc,
+                    },
+                },
+            });
+            const preCheckData = preCheckResponse.data;
+            if (!preCheckData.success || preCheckData.code !== 0) {
+                const errorMsg = `函数部署预检失败：${preCheckData.msg}`;
+                yield log(`预检失败: ${errorMsg}`, "error");
+                throw new Error(errorMsg);
+            }
+            yield log("预检通过", "success");
+            yield log("开始打包代码...", "info", true);
+            const outputDir = path_1.default.join(absWorkDir, "dist");
+            if (!fs_1.default.existsSync(outputDir)) {
+                fs_1.default.mkdirSync(outputDir, { recursive: true });
+                yield log(`创建输出目录: ${outputDir}`, "info");
+            }
+            const zipFilename = `fun-${envId}.zip`;
+            const outputPath = path_1.default.join(outputDir, zipFilename);
+            yield log(`打包文件: ${zipFilename}`, "info");
+            yield log(`输出路径: ${outputPath}`, "info");
+            yield log(includeNodeModules ? "包含 node_modules" : "排除 node_modules", "info");
+            yield new Promise((resolve, reject) => {
+                const output = fs_1.default.createWriteStream(outputPath);
+                const archive = (0, archiver_1.default)("zip", {
+                    zlib: { level: 9 },
+                });
+                output.on("close", () => __awaiter(this, void 0, void 0, function* () {
+                    yield log("代码打包完成", "success");
+                    resolve();
+                }));
+                archive.on("error", (err) => __awaiter(this, void 0, void 0, function* () {
+                    const errorMsg = `打包失败: ${err.message}`;
+                    yield log(`错误: ${errorMsg}`, "error");
+                    reject(err);
+                }));
+                archive.pipe(output);
+                archive.directory(absWorkDir, false, (data) => {
+                    const excludePatterns = [/^\.git/, /^dist/, /\.zip$/, /\.DS_Store$/];
+                    if (!includeNodeModules) {
+                        excludePatterns.push(/^node_modules/);
+                    }
+                    if (excludePatterns.some((pattern) => pattern.test(data.name))) {
+                        return false;
+                    }
+                    return data;
+                });
+                archive.finalize();
+            });
+            const stats = fs_1.default.statSync(outputPath);
+            const fileSizeMB = (stats.size / 1024 / 1024).toFixed(2);
+            yield log(`打包文件大小: ${fileSizeMB} MB`, "info");
+            yield log("开始上传代码包...", "info", true);
+            yield log("获取上传凭证...", "info", true);
+            const uploader = new cos_uploader_1.Uploader({
+                bizName: "fe",
+                scene: "fe-platform",
+                getToken: () => __awaiter(this, void 0, void 0, function* () {
+                    if (env_helper_1.isIDE) {
+                        const errorMsg = "IDE 模式暂不支持函数部署上传。";
+                        yield log(`错误: ${errorMsg}`, "error");
+                        throw new Error(errorMsg);
+                    }
+                    const permitResp = yield request_1.request.fetch({
+                        url: `${(0, config_1.getBaseUrl)()}/api/eros/mp/red/code/cloud_env_pkg/upload/permit`,
+                        method: "GET",
+                        headers: {
+                            "Content-Type": "application/json",
+                        },
+                        data: {
+                            params: {
+                                secret_id: loginInfo.secret_id,
+                                cli_token: loginInfo.cli_token,
+                            },
+                        },
+                    });
+                    if (permitResp.data.code !== 0) {
+                        const errorMsg = permitResp.data.msg || "获取上传凭证失败";
+                        yield log(`错误: ${errorMsg}`, "error");
+                        throw new Error(errorMsg);
+                    }
+                    yield log("上传凭证获取成功", "success");
+                    return permitResp.data.data;
+                }),
+            });
+            yield log("读取打包文件...", "info");
+            const file = fs_1.default.readFileSync(outputPath);
+            const fileName = path_1.default.basename(outputPath);
+            yield log(`开始上传文件: ${fileName}`, "info", true);
+            const uploadResp = yield uploader.post({
+                Body: file,
+                fileInfo: {
+                    name: fileName,
+                    type: "application/octet-stream",
+                    size: stats.size,
+                },
+                FilePath: outputPath,
+            });
+            if (!uploadResp.previewUrl) {
+                const errorMsg = "函数代码包上传失败，未获取到预览地址。";
+                yield log(`错误: ${errorMsg}`, "error");
+                throw new Error(errorMsg);
+            }
+            logger_1.logger.breakLine();
+            logger_1.logger.info(`[rcb-fun] 函数代码包上传成功: ${uploadResp.previewUrl}`);
+            yield log(`代码包上传成功: ${uploadResp.previewUrl}`, "success");
+            const fileUrl = uploadResp.previewUrl;
+            yield log("开始部署...", "info", true);
+            yield log(`环境 ID: ${envId}`, "info");
+            yield log(`文件 URL: ${fileUrl}`, "info");
+            const uploadResponse = yield request_1.request.fetch({
+                method: "POST",
+                url: `${(0, config_1.getBaseUrl)()}/api/eros/mp/red/code/cloud_env_pkg/develop/upload`,
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                data: {
+                    query: {
+                        secret_id: loginInfo.secret_id,
+                        cli_token: loginInfo.cli_token,
+                    },
+                    body: {
+                        cloud_env_id: envId,
+                        desc: baseDesc,
+                        file_url: fileUrl,
+                        cloud_type: 4,
+                    },
+                },
+            });
+            const uploadData = uploadResponse.data;
+            if (!uploadData.success || uploadData.code !== 0) {
+                const errorMsg = `函数部署失败：${uploadData.msg}`;
+                yield log(`部署失败: ${errorMsg}`, "error");
+                throw new Error(errorMsg);
+            }
+            yield log("部署成功", "success");
+            yield log(`部署结果: ${uploadData.msg || "完成"}`, "success");
+            const pkgDto = (_b = (_a = uploadResponse.data) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.cloud_env_dev_pkg_dto;
+            const publisher = pkgDto === null || pkgDto === void 0 ? void 0 : pkgDto.committerName;
+            return {
+                success: true,
+                code: uploadData.code,
+                msg: uploadData.msg,
+                publisher,
+            };
+        });
+    }
+    getPublishHistory(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const { envId, pageNo = 1, pageSize = 10 } = options;
+            const loginInfo = yield this.authService.getLoginInfo();
+            if (!loginInfo) {
+                throw new Error("未检测到登录信息，请先执行 rcb login。");
+            }
+            const response = yield request_1.request.fetch({
+                method: "POST",
+                url: `${(0, config_1.getBaseUrl)()}/api/eros/mp/red/code/cloud_env/upload_history/query`,
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                data: {
+                    query: {
+                        secret_id: loginInfo.secret_id,
+                        cli_token: loginInfo.cli_token,
+                    },
+                    body: {
+                        cloud_env_id: envId,
+                        page_no: String(pageNo),
+                        page_size: String(pageSize),
+                    },
+                },
+            });
+            const responseData = response.data;
+            if (!responseData.success || responseData.code !== 0) {
+                throw new Error(`查询发布历史失败：${responseData.msg || "未知错误"}`);
+            }
+            return {
+                pkgList: ((_a = responseData.data) === null || _a === void 0 ? void 0 : _a.pkg_list) || [],
+                total: ((_b = responseData.data) === null || _b === void 0 ? void 0 : _b.total) || 0,
+            };
+        });
+    }
+};
+exports.FunService = FunService;
+exports.FunService = FunService = __decorate([
+    (0, inversify_1.injectable)(),
+    __metadata("design:paramtypes", [])
+], FunService);

package/lib/services/index.js

@@ -16,3 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./auth-service"), exports);
 __exportStar(require("./upload-service"), exports);
+__exportStar(require("./cloud-env-service"), exports);
+__exportStar(require("./fun-service"), exports);

package/lib/utils/fun-project-validator.js

@@ -0,0 +1,212 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunProjectValidator = void 0;
+const fs_1 = __importDefault(require("fs"));
+const fs_2 = require("fs");
+const path_1 = __importDefault(require("path"));
+const path_2 = require("path");
+const util_1 = require("util");
+const readFileAsync = (0, util_1.promisify)(fs_1.default.readFile);
+const accessAsync = (0, util_1.promisify)(fs_1.default.access);
+class FunProjectValidator {
+    constructor(workDir) {
+        this.workDir = path_1.default.isAbsolute(workDir) ? workDir : path_1.default.resolve(process.cwd(), workDir);
+    }
+    validate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            const warnings = [];
+            const functionsConfigPath = path_1.default.join(this.workDir, "agent-cloudbase-functions.json");
+            if (!fs_1.default.existsSync(functionsConfigPath)) {
+                errors.push([
+                    "agent-cloudbase-functions.json 文件不存在。",
+                    "当前目录可能并不是一个“云函数（fun）项目”，请确认你选择的工作目录是否正确。",
+                    "参考文档：https://miniapp.xiaohongshu.com/doc/DC185638",
+                ].join(" "));
+                return { valid: false, errors, warnings };
+            }
+            try {
+                const functionsConfig = JSON.parse(yield readFileAsync(functionsConfigPath, "utf-8"));
+                const validationResult = yield this.validateFunctionsConfig(functionsConfig, functionsConfigPath);
+                errors.push(...validationResult.errors);
+                warnings.push(...(validationResult.warnings || []));
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    errors.push(`agent-cloudbase-functions.json 解析错误: ${error.message}`);
+                }
+                else {
+                    errors.push("agent-cloudbase-functions.json 解析错误: 未知错误");
+                }
+                return { valid: false, errors, warnings };
+            }
+            const nodeModulesPath = path_1.default.join(this.workDir, "node_modules");
+            if (!fs_1.default.existsSync(nodeModulesPath)) {
+                errors.push("node_modules 目录不存在，请先运行 npm install 或 pnpm install");
+                return { valid: false, errors, warnings };
+            }
+            const packageJsonPath = path_1.default.join(this.workDir, "package.json");
+            if (!fs_1.default.existsSync(packageJsonPath)) {
+                errors.push("package.json 文件不存在");
+                return { valid: false, errors, warnings };
+            }
+            try {
+                const depErrors = yield this.validateDependencies(packageJsonPath, nodeModulesPath);
+                errors.push(...depErrors);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    errors.push(`依赖检查失败: ${error.message}`);
+                }
+                else {
+                    errors.push("依赖检查失败: 未知错误");
+                }
+            }
+            const projectConfigPath = path_1.default.join(this.workDir, "project.config.json");
+            if (fs_1.default.existsSync(projectConfigPath)) {
+                try {
+                    const projectConfig = JSON.parse(yield readFileAsync(projectConfigPath, "utf-8"));
+                    if (projectConfig.agentId) {
+                        errors.push("当前项目可能是一个 Agent 项目，请参考 agent 发布进行操作。更多查看：https://miniapp.xiaohongshu.com/doc/DC341455");
+                        return { valid: false, errors, warnings };
+                    }
+                }
+                catch (error) {
+                    warnings.push("project.config.json 文件存在但解析失败，将忽略该文件");
+                }
+            }
+            return {
+                valid: errors.length === 0,
+                errors,
+                warnings,
+            };
+        });
+    }
+    validateFunctionsConfig(config, configPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            const warnings = [];
+            if (!config.functionsRoot) {
+                errors.push("agent-cloudbase-functions.json 中缺少 functionsRoot 字段");
+                return { valid: false, errors, warnings };
+            }
+            const configDir = (0, path_2.dirname)(configPath);
+            const functionsRoot = (0, path_2.join)(configDir, config.functionsRoot);
+            if (!(0, fs_2.existsSync)(functionsRoot)) {
+                errors.push(`functionsRoot 目录不存在: ${functionsRoot}`);
+                return { valid: false, errors, warnings };
+            }
+            if (!config.functions || !Array.isArray(config.functions)) {
+                errors.push("agent-cloudbase-functions.json 中 functions 字段必须是一个非空数组");
+                return { valid: false, errors, warnings };
+            }
+            if (config.functions.length === 0) {
+                errors.push("agent-cloudbase-functions.json 中 functions 数组不能为空，请至少配置一个函数");
+                return { valid: false, errors, warnings };
+            }
+            const functionNames = new Set();
+            const triggerPaths = new Set();
+            for (let i = 0; i < config.functions.length; i++) {
+                const fn = config.functions[i];
+                const fnIndex = i + 1;
+                if (!fn.name) {
+                    errors.push(`functions[${fnIndex}] 缺少 name 字段`);
+                    continue;
+                }
+                if (!fn.directory) {
+                    errors.push(`functions[${fnIndex}] (name: ${fn.name}) 缺少 directory 字段`);
+                    continue;
+                }
+                if (!fn.source) {
+                    errors.push(`functions[${fnIndex}] (name: ${fn.name}) 缺少 source 字段`);
+                    continue;
+                }
+                if (!fn.triggerPath) {
+                    errors.push(`functions[${fnIndex}] (name: ${fn.name}) 缺少 triggerPath 字段`);
+                    continue;
+                }
+                if (functionNames.has(fn.name)) {
+                    errors.push(`函数名重复: ${fn.name}`);
+                }
+                else {
+                    functionNames.add(fn.name);
+                }
+                if (triggerPaths.has(fn.triggerPath)) {
+                    errors.push(`triggerPath 重复: ${fn.triggerPath}`);
+                }
+                else {
+                    triggerPaths.add(fn.triggerPath);
+                }
+                const fnDirectory = (0, path_2.join)(functionsRoot, fn.directory);
+                if (!(0, fs_2.existsSync)(fnDirectory)) {
+                    errors.push(`函数目录不存在: ${fn.directory} (函数名: ${fn.name})`);
+                    continue;
+                }
+                const sourcePath = (0, path_2.join)(fnDirectory, fn.source);
+                if (!(0, fs_2.existsSync)(sourcePath)) {
+                    errors.push(`函数入口文件不存在: ${(0, path_2.join)(fn.directory, fn.source)} (函数名: ${fn.name})`);
+                    continue;
+                }
+                try {
+                    const module = require(sourcePath);
+                    if (!module[fn.name] || typeof module[fn.name] !== "function") {
+                        errors.push(`函数 ${fn.name} 在文件 ${sourcePath} 中未正确导出`);
+                    }
+                }
+                catch (error) {
+                    if (error instanceof Error) {
+                        errors.push(`函数 ${fn.name} 加载失败: ${error.message}`);
+                    }
+                    else {
+                        errors.push(`函数 ${fn.name} 加载失败: 未知错误`);
+                    }
+                }
+            }
+            return {
+                valid: errors.length === 0,
+                errors,
+                warnings,
+            };
+        });
+    }
+    validateDependencies(packageJsonPath, nodeModulesPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            try {
+                const packageJson = JSON.parse(yield readFileAsync(packageJsonPath, "utf-8"));
+                const dependencies = Object.assign(Object.assign({}, packageJson.dependencies), packageJson.devDependencies);
+                for (const [dep, version] of Object.entries(dependencies)) {
+                    const depPath = path_1.default.join(nodeModulesPath, dep);
+                    try {
+                        yield accessAsync(depPath, fs_1.default.constants.F_OK);
+                    }
+                    catch (_a) {
+                        errors.push(`依赖缺失: ${dep}@${version}`);
+                    }
+                }
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    errors.push(`依赖检查失败: ${error.message}`);
+                }
+                else {
+                    errors.push("依赖检查失败: 未知错误");
+                }
+            }
+            return errors;
+        });
+    }
+}
+exports.FunProjectValidator = FunProjectValidator;