@geek-fun/serverlessinsight 0.3.4 → 0.4.1

package/dist/src/stack/localStack/aliyunFc.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRequestId = exports.logApiGatewayRequest = exports.transformFCResponse = exports.addFCHeaders = exports.createAliyunContext = exports.createAliyunContextSerializable = exports.transformToAliyunEvent = void 0;
+const crypto_1 = require("crypto");
+const common_1 = require("../../common");
+const createFCLogger = (requestId) => {
+    const formatLog = (level, message) => {
+        const timestamp = new Date().toISOString();
+        console.log(`${timestamp} ${requestId} [${level}] ${message}`);
+    };
+    return {
+        debug: (message) => formatLog('DEBUG', message),
+        info: (message) => formatLog('INFO', message),
+        warn: (message) => formatLog('WARNING', message),
+        error: (message) => formatLog('ERROR', message),
+        log: (message) => formatLog('INFO', message),
+    };
+};
+const transformToAliyunEvent = async (req, url, query) => {
+    const rawBody = await (0, common_1.readRequestBody)(req);
+    const pathParameters = {};
+    const event = {
+        path: url,
+        httpMethod: req.method || 'GET',
+        headers: req.headers,
+        queryParameters: query,
+        pathParameters,
+        body: rawBody || undefined,
+        isBase64Encoded: false,
+    };
+    const eventBuffer = Buffer.from(JSON.stringify(event));
+    return { event: eventBuffer, headers: req.headers };
+};
+exports.transformToAliyunEvent = transformToAliyunEvent;
+const createAliyunContextSerializable = (iac, functionName, handler, memory, timeout, requestId) => {
+    return {
+        requestId,
+        region: iac.provider.region || 'cn-hangzhou',
+        accountId: process.env.ALIYUN_ACCOUNT_ID || '000000000000',
+        credentials: {
+            accessKeyId: process.env.ALIYUN_ACCESS_KEY_ID || 'mock-access-key-id',
+            accessKeySecret: process.env.ALIYUN_ACCESS_KEY_SECRET || 'mock-access-key-secret',
+            securityToken: process.env.ALIYUN_SECURITY_TOKEN || '',
+        },
+        function: {
+            name: functionName,
+            handler,
+            memory,
+            timeout,
+            initializer: '',
+        },
+        service: {
+            name: iac.service || 'default-service',
+            logProject: `${iac.service}-log-project`,
+            logStore: `${iac.service}-log-store`,
+            qualifier: 'LATEST',
+            versionId: '1',
+        },
+        tracing: {
+            spanContext: '',
+            jaegerEndpoint: '',
+            spanBaggages: {},
+        },
+    };
+};
+exports.createAliyunContextSerializable = createAliyunContextSerializable;
+const createAliyunContext = (iac, functionName, handler, memory, timeout, requestId) => {
+    const baseContext = (0, exports.createAliyunContextSerializable)(iac, functionName, handler, memory, timeout, requestId);
+    return {
+        ...baseContext,
+        tracing: {
+            ...baseContext.tracing,
+            parseOpenTracingBaggages: () => ({}),
+        },
+        logger: createFCLogger(requestId),
+    };
+};
+exports.createAliyunContext = createAliyunContext;
+const addFCHeaders = (context, headers) => {
+    return {
+        ...headers,
+        'x-fc-request-id': context.requestId,
+        'x-fc-access-key-id': context.credentials.accessKeyId,
+        'x-fc-access-key-secret': context.credentials.accessKeySecret,
+        'x-fc-security-token': context.credentials.securityToken,
+        'x-fc-function-handler': context.function.handler,
+        'x-fc-function-memory': String(context.function.memory),
+        'x-fc-region': context.region,
+        'x-fc-account-id': context.accountId,
+        'x-fc-qualifier': context.service.qualifier,
+        'x-fc-version-id': context.service.versionId,
+        'x-fc-function-name': context.function.name,
+        'x-fc-service-logproject': context.service.logProject,
+        'x-fc-service-logstore': context.service.logStore,
+        'x-fc-control-path': '/http-invoke',
+    };
+};
+exports.addFCHeaders = addFCHeaders;
+const transformFCResponse = (result) => {
+    if (result && typeof result === 'object' && 'statusCode' in result && 'body' in result) {
+        const { statusCode: rawStatus = 200, body: rawBody, isBase64Encoded, headers = {}, } = result;
+        const parsedStatus = typeof rawStatus === 'string' ? parseInt(rawStatus, 10) : rawStatus;
+        const statusCode = isNaN(parsedStatus) ? 200 : parsedStatus;
+        let body = rawBody;
+        if (isBase64Encoded && typeof body === 'string') {
+            body = Buffer.from(body, 'base64').toString('utf-8');
+        }
+        if (typeof body === 'string') {
+            try {
+                body = JSON.parse(body);
+            }
+            catch {
+                // If parsing fails, keep as string
+            }
+        }
+        return { statusCode, headers, body };
+    }
+    return {
+        statusCode: 200,
+        headers: { 'Content-Type': 'application/json' },
+        body: result,
+    };
+};
+exports.transformFCResponse = transformFCResponse;
+const logApiGatewayRequest = (requestId, apiPath, statusCode, startTime, endTime, sourceIp) => {
+    const duration = ((endTime.getTime() - startTime.getTime()) / 1000).toFixed(1);
+    const startTimeStr = formatDateTime(startTime);
+    const endTimeStr = formatDateTime(endTime);
+    const timestamp = formatDateTime(new Date());
+    console.log(`${timestamp} | ${requestId} | ${apiPath} | Sync Call | local-app | Development | local-project | ${statusCode} | ${startTimeStr} | ${endTimeStr} | ${duration}s | - | ${sourceIp}`);
+};
+exports.logApiGatewayRequest = logApiGatewayRequest;
+const formatDateTime = (date) => {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const seconds = String(date.getSeconds()).padStart(2, '0');
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+};
+const generateRequestId = () => {
+    return (0, crypto_1.randomUUID)().replace(/-/g, '');
+};
+exports.generateRequestId = generateRequestId;

package/dist/src/stack/localStack/bucket.js

@@ -0,0 +1,226 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bucketsHandler = void 0;
+const common_1 = require("../../common");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const TEXT_MIME_TYPES = new Set([
+    'text/plain',
+    'text/html',
+    'text/css',
+    'text/javascript',
+    'text/markdown',
+    'text/xml',
+    'application/json',
+    'application/javascript',
+    'application/xml',
+]);
+const getMimeType = (filename) => {
+    const ext = node_path_1.default.extname(filename).toLowerCase();
+    const mimeTypes = {
+        '.html': 'text/html',
+        '.htm': 'text/html',
+        '.css': 'text/css',
+        '.js': 'application/javascript',
+        '.json': 'application/json',
+        '.xml': 'application/xml',
+        '.txt': 'text/plain',
+        '.md': 'text/markdown',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.png': 'image/png',
+        '.gif': 'image/gif',
+        '.svg': 'image/svg+xml',
+        '.ico': 'image/x-icon',
+        '.pdf': 'application/pdf',
+        '.zip': 'application/zip',
+        '.tar': 'application/x-tar',
+        '.gz': 'application/gzip',
+    };
+    return mimeTypes[ext] || 'application/octet-stream';
+};
+const listDirectory = (dirPath, bucketPath) => {
+    try {
+        const entries = node_fs_1.default.readdirSync(dirPath, { withFileTypes: true });
+        return entries.map((entry) => {
+            const fullPath = node_path_1.default.join(dirPath, entry.name);
+            const relativePath = node_path_1.default.relative(bucketPath, fullPath);
+            const stats = node_fs_1.default.statSync(fullPath);
+            return {
+                name: entry.name,
+                type: entry.isDirectory() ? 'directory' : 'file',
+                size: entry.isDirectory() ? 0 : stats.size,
+                path: relativePath.replace(/\\/g, '/'), // Normalize path separators
+            };
+        });
+    }
+    catch (error) {
+        common_1.logger.error(`Error listing directory: ${error}`);
+        return [];
+    }
+};
+const getAllFiles = (dirPath, bucketPath, fileList = []) => {
+    try {
+        const entries = node_fs_1.default.readdirSync(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = node_path_1.default.join(dirPath, entry.name);
+            const relativePath = node_path_1.default.relative(bucketPath, fullPath);
+            if (entry.isDirectory()) {
+                // Recursively list files in subdirectories
+                getAllFiles(fullPath, bucketPath, fileList);
+            }
+            else {
+                const stats = node_fs_1.default.statSync(fullPath);
+                fileList.push({
+                    name: entry.name,
+                    type: 'file',
+                    size: stats.size,
+                    path: relativePath.replace(/\\/g, '/'),
+                });
+            }
+        }
+        return fileList;
+    }
+    catch (error) {
+        common_1.logger.error(`Error getting all files: ${error}`);
+        return fileList;
+    }
+};
+const bucketsHandler = async (req, parsed, iac) => {
+    common_1.logger.info(`Bucket request received by local server -> ${req.method} ${parsed.identifier ?? '/'} ${parsed.url}`);
+    // Find the bucket definition
+    const bucketDef = iac.buckets?.find((bucket) => bucket.key === parsed.identifier);
+    if (!bucketDef) {
+        return {
+            statusCode: 404,
+            body: { error: 'Bucket not found', bucketKey: parsed.identifier },
+        };
+    }
+    // Determine the bucket path - use website.code if available, otherwise use bucket name
+    let bucketBasePath;
+    if (bucketDef.website?.code) {
+        bucketBasePath = node_path_1.default.resolve(process.cwd(), bucketDef.website.code);
+    }
+    else {
+        // Fallback: create a directory based on bucket name (for non-website buckets)
+        bucketBasePath = node_path_1.default.resolve(process.cwd(), bucketDef.name);
+    }
+    // Check if bucket path exists
+    if (!node_fs_1.default.existsSync(bucketBasePath)) {
+        return {
+            statusCode: 404,
+            body: {
+                error: 'Bucket directory not found',
+                bucketKey: bucketDef.key,
+                bucketName: bucketDef.name,
+                expectedPath: bucketBasePath,
+            },
+        };
+    }
+    // Root path lists all files in bucket
+    if (parsed.url === '/') {
+        try {
+            const files = getAllFiles(bucketBasePath, bucketBasePath);
+            return {
+                statusCode: 200,
+                headers: { 'Content-Type': 'application/json' },
+                body: {
+                    bucket: bucketDef.name,
+                    bucketKey: bucketDef.key,
+                    files,
+                    count: files.length,
+                },
+            };
+        }
+        catch (error) {
+            common_1.logger.error(`Error listing bucket files: ${error}`);
+            return {
+                statusCode: 500,
+                body: {
+                    error: 'Failed to list bucket files',
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            };
+        }
+    }
+    // Otherwise, serve the requested file
+    const requestedPath = parsed.url.startsWith('/') ? parsed.url.slice(1) : parsed.url;
+    const filePath = node_path_1.default.join(bucketBasePath, requestedPath);
+    // Security check: ensure the requested file is within the bucket directory
+    const normalizedFilePath = node_path_1.default.normalize(filePath);
+    const normalizedBucketPath = node_path_1.default.normalize(bucketBasePath);
+    if (!normalizedFilePath.startsWith(normalizedBucketPath)) {
+        return {
+            statusCode: 403,
+            body: { error: 'Access denied: Path traversal attempt detected' },
+        };
+    }
+    // Check if file exists
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return {
+            statusCode: 404,
+            body: {
+                error: 'File not found',
+                path: requestedPath,
+                bucketKey: bucketDef.key,
+            },
+        };
+    }
+    // If it's a directory, list its contents
+    const stats = node_fs_1.default.statSync(filePath);
+    if (stats.isDirectory()) {
+        try {
+            const files = listDirectory(filePath, bucketBasePath);
+            return {
+                statusCode: 200,
+                headers: { 'Content-Type': 'application/json' },
+                body: {
+                    bucket: bucketDef.name,
+                    bucketKey: bucketDef.key,
+                    directory: requestedPath,
+                    files,
+                    count: files.length,
+                },
+            };
+        }
+        catch (error) {
+            common_1.logger.error(`Error listing directory: ${error}`);
+            return {
+                statusCode: 500,
+                body: {
+                    error: 'Failed to list directory',
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            };
+        }
+    }
+    // Serve the file
+    try {
+        const fileContent = node_fs_1.default.readFileSync(filePath);
+        const mimeType = getMimeType(filePath);
+        // For text files, return as string; for binary files, return as base64
+        const isTextFile = TEXT_MIME_TYPES.has(mimeType);
+        return {
+            statusCode: 200,
+            headers: {
+                'Content-Type': mimeType,
+                'Content-Length': String(fileContent.length),
+            },
+            body: isTextFile ? fileContent.toString('utf-8') : fileContent.toString('base64'),
+        };
+    }
+    catch (error) {
+        common_1.logger.error(`Error reading file: ${error}`);
+        return {
+            statusCode: 500,
+            body: {
+                error: 'Failed to read file',
+                message: error instanceof Error ? error.message : String(error),
+            },
+        };
+    }
+};
+exports.bucketsHandler = bucketsHandler;

package/dist/src/stack/localStack/event.js

@@ -3,36 +3,143 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startEvents = void 0;
-const node_http_1 = __importDefault(require("node:http"));
-const common_1 = require("../../common");
+exports.eventsHandler = void 0;
 const types_1 = require("../../types");
 const lodash_1 = require("lodash");
-const startApiGatewayServer = (event) => {
-    const server = node_http_1.default.createServer((req, res) => {
-        const matchedTrigger = event.triggers.find((trigger) => trigger.method === req.method && trigger.path === req.url);
-        if (!matchedTrigger) {
-            res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
-            res.end('Not Found\n');
-            common_1.logger.warn(`API Gateway Event - ${req.method} ${req.url} -> Not Found`);
-            return;
+const common_1 = require("../../common");
+const function_1 = require("./function");
+const aliyunFc_1 = require("./aliyunFc");
+const functionRunner_1 = require("./functionRunner");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const utils_1 = require("./utils");
+const matchTrigger = (req, trigger) => {
+    if (req.method !== 'ANY' && req.method !== trigger.method) {
+        return false;
+    }
+    const normalize = (s) => s.replace(/^\/+|\/+$/g, '');
+    const [pathSegments, triggerSegments] = [
+        normalize(req.path).split('/'),
+        normalize(trigger.path).split('/'),
+    ];
+    const hasWildcard = triggerSegments[triggerSegments.length - 1] === '*';
+    const prefixSegments = hasWildcard ? triggerSegments.slice(0, -1) : triggerSegments;
+    const minRequiredSegments = prefixSegments.length;
+    if (pathSegments.length < minRequiredSegments)
+        return false;
+    return prefixSegments.every((triggerSegment, index) => {
+        const pathSegment = pathSegments[index];
+        if (triggerSegment.startsWith('[') && triggerSegment.endsWith(']')) {
+            return pathSegment !== '';
         }
-        res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
-        res.end(`Invoked backend: ${matchedTrigger.backend}\n`);
-        common_1.logger.info(`API Gateway Event - ${req.method} ${req.url} -> ${matchedTrigger.backend}`);
-    });
-    const port = 3000 + Math.floor(Math.random() * 1000);
-    server.listen(port, () => {
-        common_1.logger.info(`API Gateway "${event.name}" listening on http://localhost:${port}`);
+        return triggerSegment === pathSegment;
     });
 };
-const startEvents = (events) => {
-    const apiGateways = events?.filter((event) => event.type === types_1.EventTypes.API_GATEWAY);
-    if ((0, lodash_1.isEmpty)(apiGateways)) {
-        return;
+const servEvent = async (req, parsed, iac) => {
+    const startTime = new Date();
+    const requestId = (0, aliyunFc_1.generateRequestId)();
+    const sourceIp = req.socket?.remoteAddress || '127.0.0.1';
+    const isAliyun = iac.provider.name === common_1.ProviderEnum.ALIYUN;
+    const event = iac.events?.find((event) => event.type === types_1.EventTypes.API_GATEWAY && event.key === parsed.identifier);
+    if ((0, lodash_1.isEmpty)(event)) {
+        return {
+            statusCode: 404,
+            body: { error: 'API Gateway event not found', event: parsed.identifier },
+        };
     }
-    apiGateways.forEach((gateway) => {
-        startApiGatewayServer(gateway);
-    });
+    common_1.logger.info(`Event trigger ${JSON.stringify(event.triggers)}, req method: ${req.method}, req url${req.url}`);
+    const matchedTrigger = event.triggers.find((trigger) => matchTrigger({ method: parsed.method, path: parsed.url }, trigger));
+    if (!matchedTrigger) {
+        const endTime = new Date();
+        if (isAliyun) {
+            (0, aliyunFc_1.logApiGatewayRequest)(requestId, parsed.url, 404, startTime, endTime, sourceIp);
+        }
+        return { statusCode: 404, body: { error: 'No matching trigger found' } };
+    }
+    if (matchedTrigger.backend) {
+        const backendDef = (0, common_1.getIacDefinition)(iac, matchedTrigger.backend);
+        if (!backendDef) {
+            const endTime = new Date();
+            if (isAliyun) {
+                (0, aliyunFc_1.logApiGatewayRequest)(requestId, parsed.url, 500, startTime, endTime, sourceIp);
+            }
+            return {
+                statusCode: 500,
+                body: { error: 'Backend definition missing', backend: matchedTrigger.backend },
+            };
+        }
+        // For Aliyun, handle the function execution with proper event transformation
+        if (isAliyun && backendDef.code) {
+            let tempDir = null;
+            try {
+                const { event: aliyunEvent } = await (0, aliyunFc_1.transformToAliyunEvent)(req, parsed.url, parsed.query);
+                const codePath = node_path_1.default.resolve(process.cwd(), backendDef.code.path);
+                let codeDir;
+                if (codePath.endsWith('.zip') && node_fs_1.default.existsSync(codePath)) {
+                    tempDir = await (0, utils_1.extractZipFile)(codePath);
+                    codeDir = tempDir;
+                }
+                else if (node_fs_1.default.existsSync(codePath) && node_fs_1.default.statSync(codePath).isDirectory()) {
+                    codeDir = codePath;
+                }
+                else {
+                    codeDir = node_path_1.default.dirname(codePath);
+                }
+                const funOptions = {
+                    codeDir,
+                    functionKey: backendDef.key,
+                    handler: backendDef.code.handler,
+                    servicePath: '',
+                    timeout: backendDef.timeout * 1000,
+                };
+                const aliyunContext = (0, aliyunFc_1.createAliyunContextSerializable)(iac, backendDef.name, backendDef.code.handler, backendDef.memory, backendDef.timeout, requestId);
+                const env = {
+                    ...backendDef.environment,
+                };
+                common_1.logger.debug(`Invoking FC function with Aliyun event format`);
+                const result = await (0, functionRunner_1.invokeFunction)(funOptions, env, aliyunEvent, aliyunContext);
+                const endTime = new Date();
+                const transformed = (0, aliyunFc_1.transformFCResponse)(result);
+                // Log API Gateway request
+                (0, aliyunFc_1.logApiGatewayRequest)(requestId, parsed.url, transformed.statusCode, startTime, endTime, sourceIp);
+                return {
+                    statusCode: transformed.statusCode,
+                    headers: transformed.headers,
+                    body: transformed.body,
+                };
+            }
+            catch (error) {
+                const endTime = new Date();
+                (0, aliyunFc_1.logApiGatewayRequest)(requestId, parsed.url, 500, startTime, endTime, sourceIp);
+                common_1.logger.error(`Function execution error: ${error}`);
+                return {
+                    statusCode: 500,
+                    body: {
+                        error: 'Function execution failed',
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                };
+            }
+            finally {
+                if (tempDir && node_fs_1.default.existsSync(tempDir)) {
+                    node_fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+                }
+            }
+        }
+        // For non-Aliyun or when using functionsHandler
+        const result = await (0, function_1.functionsHandler)(req, { ...parsed, identifier: backendDef?.key }, iac);
+        const endTime = new Date();
+        if (isAliyun) {
+            (0, aliyunFc_1.logApiGatewayRequest)(requestId, parsed.url, result.statusCode, startTime, endTime, sourceIp);
+        }
+        return result;
+    }
+    return {
+        statusCode: 202,
+        body: { message: 'Trigger matched but no backend configured' },
+    };
+};
+const eventsHandler = async (req, parsed, iac) => {
+    return await servEvent(req, parsed, iac);
 };
-exports.startEvents = startEvents;
+exports.eventsHandler = eventsHandler;

package/dist/src/stack/localStack/function.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionsHandler = void 0;
+const common_1 = require("../../common");
+const functionRunner_1 = require("./functionRunner");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const aliyunFc_1 = require("./aliyunFc");
+const utils_1 = require("./utils");
+const functionsHandler = async (req, parsed, iac) => {
+    common_1.logger.info(`Function request received by local server -> ${req.method} ${parsed.identifier ?? '/'} `);
+    const fcDef = iac.functions?.find((fn) => fn.key === parsed.identifier);
+    if (!fcDef) {
+        return {
+            statusCode: 404,
+            body: { error: 'Function not found', functionKey: parsed.identifier },
+        };
+    }
+    if (!fcDef.code) {
+        return {
+            statusCode: 400,
+            body: { error: 'Function code configuration not found', functionKey: fcDef.key },
+        };
+    }
+    let tempDir = null;
+    try {
+        const codePath = node_path_1.default.resolve(process.cwd(), fcDef.code.path);
+        let codeDir;
+        if (codePath.endsWith('.zip') && node_fs_1.default.existsSync(codePath)) {
+            tempDir = await (0, utils_1.extractZipFile)(codePath);
+            codeDir = tempDir;
+        }
+        else if (node_fs_1.default.existsSync(codePath) && node_fs_1.default.statSync(codePath).isDirectory()) {
+            codeDir = codePath;
+        }
+        else {
+            codeDir = node_path_1.default.dirname(codePath);
+        }
+        const funOptions = {
+            codeDir,
+            functionKey: fcDef.key,
+            handler: fcDef.code.handler,
+            servicePath: '',
+            timeout: fcDef.timeout * 1000,
+        };
+        // Check if provider is Aliyun to use Aliyun FC format
+        const isAliyun = iac.provider.name === common_1.ProviderEnum.ALIYUN;
+        let event;
+        let fcContext;
+        let env;
+        if (isAliyun) {
+            // Aliyun FC format: event is a Buffer containing JSON
+            const requestId = (0, aliyunFc_1.generateRequestId)();
+            const { event: aliyunEvent } = await (0, aliyunFc_1.transformToAliyunEvent)(req, parsed.url, parsed.query);
+            event = aliyunEvent;
+            // Use serializable context for worker thread (logger will be added inside worker)
+            fcContext = (0, aliyunFc_1.createAliyunContextSerializable)(iac, fcDef.name, fcDef.code.handler, fcDef.memory, fcDef.timeout, requestId);
+            env = {
+                ...fcDef.environment,
+            };
+        }
+        else {
+            // AWS Lambda format (default)
+            const rawBody = await (0, common_1.readRequestBody)(req);
+            event = rawBody ? JSON.parse(rawBody) : {};
+            env = {
+                ...fcDef.environment,
+                AWS_REGION: iac.provider.region || 'us-east-1',
+                FUNCTION_NAME: fcDef.name,
+                FUNCTION_MEMORY_SIZE: String(fcDef.memory),
+                FUNCTION_TIMEOUT: String(fcDef.timeout),
+            };
+            fcContext = {
+                functionName: fcDef.name,
+                functionVersion: '$LATEST',
+                memoryLimitInMB: fcDef.memory,
+                logGroupName: `/aws/lambda/${fcDef.name}`,
+                logStreamName: `${new Date().toISOString().split('T')[0]}/[$LATEST]${Math.random().toString(36).substring(7)}`,
+                invokedFunctionArn: `arn:aws:lambda:${iac.provider.region}:000000000000:function:${fcDef.name}`,
+                awsRequestId: Math.random().toString(36).substring(2, 15),
+            };
+        }
+        common_1.logger.debug(`Invoking worker with event type: ${isAliyun ? 'Buffer' : 'Object'} and context`);
+        common_1.logger.debug(`Worker codeDir: ${codeDir}, handler: ${funOptions.handler}`);
+        const result = await (0, functionRunner_1.invokeFunction)(funOptions, env, event, fcContext);
+        common_1.logger.info(`Function execution result: ${JSON.stringify(result)}`);
+        // For Aliyun, transform FC response to HTTP response if needed
+        if (isAliyun && result) {
+            const transformed = (0, aliyunFc_1.transformFCResponse)(result);
+            return {
+                statusCode: transformed.statusCode,
+                headers: transformed.headers,
+                body: transformed.body,
+            };
+        }
+        return {
+            statusCode: 200,
+            body: result,
+        };
+    }
+    catch (error) {
+        common_1.logger.error(`Function execution error: ${error}`);
+        return {
+            statusCode: 500,
+            body: {
+                error: 'Function execution failed',
+                message: error instanceof Error ? error.message : String(error),
+            },
+        };
+    }
+    finally {
+        if (tempDir && node_fs_1.default.existsSync(tempDir)) {
+            node_fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        }
+    }
+};
+exports.functionsHandler = functionsHandler;