@vectorx/functions-framework 0.0.0-beta-20251112071234

package/README.md

@@ -0,0 +1,141 @@
+# VectorX Functions Framework
+
+VectorX Functions Framework 是一个用于构建和运行云函数的框架，提供了完整的日志系统支持。
+
+## 日志系统
+
+框架内置了完整的日志系统，支持请求日志记录和用户代码日志记录。
+
+### 配置
+
+在初始化框架时，可以配置日志系统：
+
+```typescript
+import { createAgentServerFramework } from '@vectorx/functions-framework';
+
+const framework = createAgentServerFramework({
+    port: 3000,
+    logging: {
+        dirname: '/path/to/logs',  // 日志存储目录
+        maxSize: '20m',           // 单个日志文件最大大小
+        maxFiles: 14              // 保留的日志文件数量
+    }
+});
+```
+
+### 日志类型
+
+框架支持两种类型的日志：
+
+- `ACCESS`: 访问日志，记录所有 HTTP 请求
+- `USERCODE`: 用户代码日志，记录用户函数中的日志
+
+### 日志查询 API
+
+框架提供了日志查询 API，用于查看和调试日志：
+
+```
+GET /@logs
+```
+
+#### 查询参数
+
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| type | string | 否 | 日志类型，可选值：ACCESS/USERCODE，默认 ACCESS |
+| limit | number | 否 | 返回的日志条数限制，默认 100 |
+| eventId | string | 否 | 按 eventId 过滤日志 |
+
+#### 示例
+
+1. 查询所有访问日志：
+```bash
+curl 'http://localhost:3000/@logs?type=ACCESS'
+```
+
+2. 查询特定 eventId 的日志：
+```bash
+curl 'http://localhost:3000/@logs?eventId=550e8400-e29b-41d4-a716-446655440000'
+```
+
+3. 限制返回条数：
+```bash
+curl 'http://localhost:3000/@logs?limit=10'
+```
+
+4. 组合查询：
+```bash
+curl 'http://localhost:3000/@logs?type=USERCODE&eventId=550e8400-e29b-41d4-a716-446655440000&limit=20'
+```
+
+#### 响应格式
+
+成功响应：
+```json
+{
+    "success": true,
+    "data": [
+        {
+            "@timestamp": "2024-03-21T10:30:00.000Z",
+            "level": "info",
+            "eventId": "550e8400-e29b-41d4-a716-446655440000",
+            "message": "Request started",
+            "method": "GET",
+            "url": "/api/example"
+        }
+    ]
+}
+```
+
+错误响应：
+```json
+{
+    "success": false,
+    "error": "错误信息"
+}
+```
+
+### 在代码中使用日志
+
+```typescript
+import { functionsLogger } from '@vectorx/functions-framework';
+import { LogLevel } from '@vectorx/functions-framework';
+
+// 记录访问日志
+functionsLogger.logAccesslog(LogLevel.INFO, 'Custom message', {
+    customField: 'value'
+});
+
+// 记录用户代码日志
+functionsLogger.logUserCodelog([
+    { message: 'User log message', level: 'info' }
+]);
+```
+
+### 日志格式
+
+每条日志都包含以下字段：
+
+- `@timestamp`: 日志时间戳
+- `level`: 日志级别
+- `eventId`: 请求 ID
+- `message`: 日志消息
+- 其他自定义字段
+
+## 开发
+
+### 运行测试
+
+```bash
+npm test
+```
+
+### 构建
+
+```bash
+npm run build
+``` 
+
+
+### 环境管理
+读取 .env 文件，校验 env 文件的可用性，获取当前运行环境

package/bin/rcb-ff.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const { createAgentServerFramework, getDependencyVersion } = require('../lib');
+const path = require('path');
+const fs = require('fs');
+const nodemon = require('nodemon');
+const chalk = require('chalk');
+
+const program = new Command();
+
+program
+    .name('rcb-ff')
+    .description('RCB Functions Framework CLI')
+    .version('0.1.0')
+    .option('-d, --directory <path>', '指定函数目录路径', process.cwd())
+    .option('-p, --port <number>', '指定服务端口', '3000')
+    .option('-t, --target <string>', '指定目标函数名', 'main')
+    .option('-s, --source <string>', '指定源文件路径', 'index.js')
+    .option('--enable-cors', '启用 CORS')
+    .option('--allowed-origins <origins>', 'CORS 允许的域名，用逗号分隔', 'localhost,127.0.0.1')
+    .option('--config <path>', '指定配置文件路径', 'agent-cloudbase-functions.json')
+    .option('--enableRedLangfuse', '启用 Red Langfuse 上报')
+    .option('-w, --watch', '启用文件监听模式，文件变化时自动重启服务');
+
+program.parse();
+
+const options = program.opts();
+
+async function startServer() {
+    try {
+        // 解析并验证目录路径
+        const directory = path.resolve(options.directory);
+        if (!fs.existsSync(directory)) {
+            console.error(`错误: 目录不存在: ${directory}`);
+            process.exit(1);
+        }
+
+        // 构建框架配置
+        const frameworkOptions = {
+            port: parseInt(options.port),
+            target: options.target,
+            sourceLocation: options.source,
+            timeoutMS: process.env.FUNCTION_TIMEOUT ? parseInt(process.env.FUNCTION_TIMEOUT) : 0,
+            keepAliveTimeoutMS: process.env.FUNCTION_KEEPALIVE ? parseInt(process.env.FUNCTION_KEEPALIVE) : 25000,
+            functionsConfigFile: path.resolve(directory, options.config),
+            enableCors: options.enableCors,
+            allowedOrigins: options.allowedOrigins.split(','),
+            redLangfuseConfig: {
+                enable: Boolean(options.enableRedLangfuse),
+            },
+            kitInfo: {
+                agentRuntimeVersion: getDependencyVersion('@vectorx/agent-runtime', directory),
+                functionsFrameworkVersion: getDependencyVersion('@vectorx/functions-framework', directory)
+            }
+        };
+
+        // 切换到目标目录
+        process.chdir(directory);
+        
+        // 创建独立的控制台实例，避免被框架拦截
+        const startupConsole = new console.Console({
+            stdout: process.stdout,
+            stderr: process.stderr
+        });
+        
+        startupConsole.log(`工作目录: ${directory}`);
+
+        // 启动框架
+        const framework = createAgentServerFramework(frameworkOptions);
+        const server = await framework.startServer();
+
+        server.listen(frameworkOptions.port, () => {
+            // 使用独立的控制台实例打印启动信息
+            startupConsole.log('\n\n' + chalk.bold.cyan(' === RCB Functions Framework ==='));
+            startupConsole.log(`${chalk.green('✔')} ${chalk.bold('状态')}: ${chalk.green('运行中')}`);
+            startupConsole.log(`${chalk.green('✔')} ${chalk.bold('端口')}: ${chalk.yellow(frameworkOptions.port)}`);
+            startupConsole.log(`${chalk.green('✔')} ${chalk.bold('URL')}: ${chalk.blue.underline(`http://localhost:${frameworkOptions.port}`)}`);
+            startupConsole.log(`${chalk.green('✔')} ${chalk.bold('目标函数')}: ${chalk.yellow(frameworkOptions.target)}`);
+            startupConsole.log(`${chalk.green('✔')} ${chalk.bold('配置文件')}: ${chalk.dim(frameworkOptions.functionsConfigFile)}`);
+            startupConsole.log(`${chalk.green('✔')} ${chalk.bold('CORS')}: ${frameworkOptions.enableCors ? chalk.green('启用') : chalk.red('禁用')}`);
+            startupConsole.log(`${chalk.green('✔')} ${chalk.bold('源文件')}: ${chalk.dim(frameworkOptions.sourceLocation)}`);
+            startupConsole.log(`${chalk.green('✔')} ${chalk.bold('已注册的函数')}: ${chalk.yellow(framework.getRegisteredFunction('@fn:main'))}`);
+            if (frameworkOptions.enableCors) {
+                startupConsole.log(`${chalk.green('✔')} ${chalk.bold('允许的域名')}: ${chalk.dim(frameworkOptions.allowedOrigins.join(', '))}`);
+            }
+
+            if (typeof process.send === 'function') {   
+                process.send({
+                    type: 'start-up',
+                    status: 'success',
+                    timestamp: Date.now()
+                });
+            }
+        });
+
+        process.on('SIGTERM', () => {
+            startupConsole.log('\n接收到 SIGTERM 信号: 正在关闭 HTTP 服务器');
+            server.close(() => {
+                startupConsole.log('HTTP 服务器已关闭');
+                process.exit(0);
+            });
+        });
+
+        process.on('SIGINT', () => {
+            startupConsole.log('\n接收到 Ctrl+C: 正在关闭 HTTP 服务器');
+            server.close(() => {
+                startupConsole.log('HTTP 服务器已关闭');
+            });
+            process.exit(0);
+        });
+
+    } catch (err) {
+        console.error('启动服务器失败:', err);
+        process.exit(1);
+    }
+}
+
+async function main() {
+    if (options.watch) {
+        // 使用 nodemon 启动并监听文件变化
+        const script = path.join(__dirname, 'rcb-ff.js');
+        const args = process.argv.slice(2).filter(arg => arg !== '-w' && arg !== '--watch');
+        
+        nodemon({
+            script: script,
+            args: args,
+            watch: [options.directory],
+            ext: 'js,json,ts,tsx,jsx',
+            ignore: ['node_modules/**/*'],
+            delay: 1000,
+        })
+        .on('start', () => {
+            console.log('\n🔄 监听模式已启动...');
+        })
+        .on('restart', (files) => {
+            console.log('\n🔄 检测到文件变化，正在重启服务...');
+            console.log('变更文件:', files);
+        })
+        .on('crash', () => {
+            console.log('\n💥 服务崩溃，等待文件变化后重启...');
+        })
+        .on('quit', () => {
+            console.log('\n👋 监听模式已退出');
+            process.exit();
+        });
+    } else {
+        // 直接启动服务
+        await startServer();
+    }
+}
+
+main(); 

package/lib/async-context.js

@@ -0,0 +1,61 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newExecutionContext = newExecutionContext;
+exports.getCurrentEventID = getCurrentEventID;
+exports.getCurrentAsyncContext = getCurrentAsyncContext;
+exports.isInFrameworkAsyncContext = isInFrameworkAsyncContext;
+exports.done = done;
+exports.wrapWithAsyncContext = wrapWithAsyncContext;
+const async_hooks_1 = require("async_hooks");
+const CONTEXT_ID = Symbol("@vectorx/functions-framework");
+const asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
+function newExecutionContext(eventId, apmData) {
+    return {
+        id: CONTEXT_ID,
+        eventID: eventId,
+        done: false,
+        userCodeLogs: [],
+        apmMeasurementData: apmData ? Object.assign({}, apmData) : undefined,
+    };
+}
+function getCurrentEventID() {
+    const context = asyncLocalStorage.getStore();
+    return (context === null || context === void 0 ? void 0 : context.eventID) || "";
+}
+function getCurrentAsyncContext() {
+    return asyncLocalStorage.getStore();
+}
+function isInFrameworkAsyncContext() {
+    const context = asyncLocalStorage.getStore();
+    return context !== undefined && context.id === CONTEXT_ID;
+}
+function done() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = asyncLocalStorage.getStore();
+        if (context !== undefined) {
+            context.done = true;
+        }
+    });
+}
+function wrapWithAsyncContext(executionContext, fn) {
+    return asyncLocalStorage.run(executionContext, () => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const result = yield fn();
+            yield done();
+            return result;
+        }
+        catch (error) {
+            yield done();
+            throw error;
+        }
+    }));
+}

package/lib/config.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBaseUrl = getBaseUrl;
+const ENV_BASE_URL = {
+    development: "https://agentbase-sandbox.xiaohongshu.com",
+    production: "https://agentbase.xiaohongshu.com",
+};
+function getBaseUrl() {
+    return ENV_BASE_URL[process.env.OPEN_PLATFORM_STAGE] || ENV_BASE_URL.development;
+}

package/lib/constants.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOptions = void 0;
+exports.defaultOptions = {
+    port: 3000,
+    timeoutMS: 0,
+    keepAliveTimeoutMS: 25000,
+    functionsConfigFile: "agent-cloudbase-functions.json",
+    enableCors: false,
+};

package/lib/error.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCode = exports.AppError = void 0;
+exports.decorateErrorStack = decorateErrorStack;
+exports.newSysErr = newSysErr;
+exports.newBadRequestErr = newBadRequestErr;
+exports.newTimeoutErr = newTimeoutErr;
+exports.newTooManyRequestsErr = newTooManyRequestsErr;
+exports.newUnauthorizedErr = newUnauthorizedErr;
+class AppError extends Error {
+    constructor(code, message, options) {
+        super(message);
+        this.code = code;
+        this.cause = options.cause;
+    }
+}
+exports.AppError = AppError;
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode[ErrorCode["SYS_ERR"] = 500] = "SYS_ERR";
+    ErrorCode[ErrorCode["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    ErrorCode[ErrorCode["TIMEOUT"] = 408] = "TIMEOUT";
+    ErrorCode[ErrorCode["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+    ErrorCode[ErrorCode["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
+function decorateErrorStack(err) {
+    if (!err || typeof err.message !== "string" || typeof err.stack !== "string") {
+        return "";
+    }
+    return err.stack.split("\n").join("\n");
+}
+function newSysErr(err) {
+    return new AppError(ErrorCode.SYS_ERR, "System Error.", { cause: err });
+}
+function newBadRequestErr(err) {
+    const message = err instanceof Error ? err.message : err;
+    return new AppError(ErrorCode.BAD_REQUEST, message, { cause: err });
+}
+function newTimeoutErr() {
+    return new AppError(ErrorCode.TIMEOUT, "Request timeout", { cause: new Error("Request timeout") });
+}
+function newTooManyRequestsErr(err) {
+    return new AppError(ErrorCode.TOO_MANY_REQUESTS, "Too many requests", { cause: err });
+}
+function newUnauthorizedErr(err) {
+    return new AppError(ErrorCode.UNAUTHORIZED, "Unauthorized", { cause: err });
+}

package/lib/framework.js

@@ -0,0 +1,183 @@
+"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.getDependencyVersion = getDependencyVersion;
+exports.createAgentServerFramework = createAgentServerFramework;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const constants_1 = require("./constants");
+const function_loader_1 = require("./function-loader");
+const function_registry_1 = require("./function-registry");
+const logger_1 = require("./logger");
+const router_1 = require("./router");
+const server_1 = require("./server");
+const apm_1 = require("./utils/apm");
+const console_intercept_1 = require("./utils/console-intercept");
+function getDependencyVersion(packageName, searchPath) {
+    try {
+        const packagePath = require.resolve(packageName, { paths: [searchPath] });
+        let currentPath = path_1.default.dirname(packagePath);
+        let packageJsonPath = path_1.default.join(currentPath, "package.json");
+        while (!(0, fs_1.existsSync)(packageJsonPath) && currentPath !== path_1.default.parse(currentPath).root) {
+            currentPath = path_1.default.dirname(currentPath);
+            packageJsonPath = path_1.default.join(currentPath, "package.json");
+        }
+        if ((0, fs_1.existsSync)(packageJsonPath)) {
+            const pkg = require(packageJsonPath);
+            return pkg.version || null;
+        }
+        return null;
+    }
+    catch (e) {
+        return null;
+    }
+}
+class AgentServerFramework {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f;
+        this.options = Object.assign(Object.assign({}, constants_1.defaultOptions), options);
+        this.apmReporter = new apm_1.ApmReporter();
+        console_intercept_1.Interceptor.intercept();
+        logger_1.functionsLogger.init([
+            {
+                type: logger_1.LogType.ACCESS,
+                options: {
+                    dirname: (_a = options.logging) === null || _a === void 0 ? void 0 : _a.dirname,
+                    maxSize: (_b = options.logging) === null || _b === void 0 ? void 0 : _b.maxSize,
+                    maxFiles: (_c = options.logging) === null || _c === void 0 ? void 0 : _c.maxFiles,
+                },
+            },
+            {
+                type: logger_1.LogType.USERCODE,
+                options: {
+                    dirname: (_d = options.logging) === null || _d === void 0 ? void 0 : _d.dirname,
+                    maxSize: (_e = options.logging) === null || _e === void 0 ? void 0 : _e.maxSize,
+                    maxFiles: (_f = options.logging) === null || _f === void 0 ? void 0 : _f.maxFiles,
+                },
+            },
+        ]);
+        logger_1.functionsLogger.setApmReporter(this.apmReporter);
+    }
+    startServer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { functionsConfigFile } = this.options;
+            let cloudFunctionConfig;
+            console.log("==== process.env.OPEN_PLATFORM_STAGE ====", process.env.OPEN_PLATFORM_STAGE);
+            if (!process.env.OPEN_PLATFORM_STAGE) {
+                process.stdout.write(chalk_1.default.yellow(`未设置 OPEN_PLATFORM_STAGE 环境变量，使用默认值: development\n`));
+                process.env.OPEN_PLATFORM_STAGE = "development";
+            }
+            const stage = process.env.OPEN_PLATFORM_STAGE || "development";
+            const defaultEnvFilePath = path_1.default.join(process.cwd(), ".env");
+            const stageEnvFilePath = path_1.default.join(process.cwd(), `.env.${stage}`);
+            let dotEnvContent;
+            if ((0, fs_1.existsSync)(defaultEnvFilePath)) {
+                dotEnvContent = dotenv_1.default.config({ path: path_1.default.resolve(defaultEnvFilePath) });
+            }
+            else if ((0, fs_1.existsSync)(stageEnvFilePath)) {
+                dotEnvContent = dotenv_1.default.config({ path: path_1.default.resolve(stageEnvFilePath) });
+            }
+            if (dotEnvContent && dotEnvContent.parsed) {
+                const envKeys = Object.keys(dotEnvContent.parsed);
+                envKeys.forEach((key) => {
+                    const regexForComment = / #+.*$/g;
+                    const envValue = dotEnvContent.parsed[key];
+                    if (regexForComment.test(envValue)) {
+                        process.stdout.write(chalk_1.default.yellow(`在dotenv配置中字段${key}发现 #,请确保注释都写在单独由#开头的新一行, 不支持行内注释。
+                            详情查看：https://github.com/motdotla/dotenv#rules\n`));
+                    }
+                });
+            }
+            const projectConfigPath = path_1.default.join(process.cwd(), "project.config.json");
+            if (!(0, fs_1.existsSync)(projectConfigPath)) {
+                throw new Error(`
+❌ 项目配置文件未找到: ${projectConfigPath}
+
+请确保:
+1. 配置文件 'project.config.json' 存在于项目根目录
+2. 配置文件格式正确，示例:
+{
+  "agentId": "示例 agentId ",
+  "version": "0.0.1",
+  "desc": "发布示例",
+}
+`);
+            }
+            const projectConfig = require(projectConfigPath);
+            if (!(0, fs_1.existsSync)(functionsConfigFile)) {
+                throw new Error(`
+❌ 配置文件未找到: ${functionsConfigFile}
+
+请确保:
+1. 配置文件 'agent-cloudbase-functions.json' 存在于项目根目录
+2. 配置文件格式正确，示例:
+{
+  "functionsRoot": "./src",
+  "functions": [
+    {
+      "name": "main",
+      "directory": "./",
+      "source": "index.js",
+      "triggerPath": "/"
+    }
+  ]
+}
+`);
+            }
+            try {
+                cloudFunctionConfig = (0, function_loader_1.loadFunctionsConfig)(functionsConfigFile);
+                for (const fn of cloudFunctionConfig.functions) {
+                    const mainFn = (0, function_loader_1.loadFunction)(cloudFunctionConfig.functionsRoot, fn);
+                    if (!mainFn) {
+                        throw new Error(`
+❌ 函数加载失败: ${fn.name}
+
+请检查:
+1. 函数目录是否存在: ${path_1.default.join(cloudFunctionConfig.functionsRoot, fn.directory)}
+2. 源文件是否存在: ${fn.source}
+3. 函数是否正确导出
+`);
+                    }
+                    (0, function_registry_1.registerFunction)(fn.name, mainFn);
+                }
+                this.router = new router_1.Router(cloudFunctionConfig);
+            }
+            catch (err) {
+                throw new Error(`
+❌ 函数配置加载失败
+
+错误详情: ${err}
+
+请检查:
+1. 配置文件格式是否正确
+2. 所有引用的路径是否存在
+3. 函数是否正确实现
+
+配置文件路径: ${functionsConfigFile}
+`);
+            }
+            const server = (0, server_1.createServer)(this.options, this.router, projectConfig);
+            return server;
+        });
+    }
+    getRegisteredFunction(fnName) {
+        return (0, function_registry_1.getRegisteredFunction)(fnName);
+    }
+}
+function createAgentServerFramework(options) {
+    const agentInstance = new AgentServerFramework(options);
+    return agentInstance;
+}

package/lib/function-loader.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FN_NAME = void 0;
+exports.loadFunctionsConfig = loadFunctionsConfig;
+exports.loadFunction = loadFunction;
+const fs_1 = require("fs");
+const path_1 = require("path");
+exports.DEFAULT_FN_NAME = "main";
+function loadFunctionsConfig(configPath) {
+    try {
+        const config = require(configPath);
+        config.functionsRoot = (0, path_1.join)((0, path_1.dirname)(configPath), config.functionsRoot);
+        if (!config.functions) {
+            config.functions = [];
+        }
+        if (!config.routes) {
+            config.routes = [];
+        }
+        const routeMaps = new Map();
+        if (Array.isArray(config.functions)) {
+            for (const fn of config.functions) {
+                if (fn.triggerPath) {
+                    if (routeMaps.has(fn.triggerPath)) {
+                        const existsTriggerFnName = routeMaps.get(fn.triggerPath);
+                        if (existsTriggerFnName === fn.name) {
+                            console.warn(`Route '${fn.triggerPath}'-> '${fn.name}' already exists, ignore.`);
+                            continue;
+                        }
+                        else {
+                            throw new Error(`Route '${fn.triggerPath}->${fn.name}' conflict with '${fn.triggerPath}->${existsTriggerFnName}', please check your functions config`);
+                        }
+                    }
+                    config.routes.push({ functionName: fn.name, path: fn.triggerPath });
+                    routeMaps.set(fn.triggerPath, fn.name);
+                }
+            }
+        }
+        return config;
+    }
+    catch (err) {
+        throw new Error(`Failed to load functions config: ${err}`);
+    }
+}
+function loadFunction(functionsRoot, functionConfig) {
+    if (!functionConfig.source) {
+        functionConfig.source = exports.DEFAULT_FN_NAME;
+    }
+    const indexPath = (0, path_1.join)(functionsRoot, functionConfig.source);
+    if (!(0, fs_1.existsSync)(indexPath)) {
+        throw new Error(`Function entry file not found at: ${indexPath}, functionConfig: ${JSON.stringify(functionConfig)}`);
+    }
+    try {
+        const module = require(indexPath);
+        const fn = module[functionConfig.name];
+        if (typeof fn !== "function") {
+            throw new Error(`Function '${functionConfig.name}' not found in ${indexPath}`);
+        }
+        return fn;
+    }
+    catch (err) {
+        throw new Error(`Failed to load function '${functionConfig.name}': ${err}`);
+    }
+}