persona-core 1.0.0

package/dist/services/actionService.js

@@ -0,0 +1,971 @@
+/**
+ * 统一的 ActionService 实现
+ * 通过注入 ContentGenerationCapability 支持不同的 LLM 提供者
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import nunjucks from 'nunjucks';
+import { FileLoader } from './loaders/index.js';
+export class DefaultActionService {
+    contentGeneration;
+    defaultOptions;
+    asyncTaskContexts = new Map();
+    fileConfig;
+    fileLoader;
+    nunjucksEnv;
+    constructor(
+    /** LLM 内容生成能力（用于 llm_call 类型） */
+    contentGeneration, defaultOptions, 
+    /** 文件操作配置 */
+    fileConfig) {
+        this.contentGeneration = contentGeneration;
+        this.defaultOptions = defaultOptions;
+        this.fileConfig = {
+            baseDir: fileConfig?.baseDir ?? process.cwd(),
+            allowedExtensions: fileConfig?.allowedExtensions ?? [],
+            maxFileSize: fileConfig?.maxFileSize ?? 10 * 1024 * 1024, // 10MB
+        };
+        this.fileLoader = new FileLoader(this.fileConfig.baseDir, this.fileConfig.maxFileSize);
+        // 初始化 Nunjucks 环境
+        this.nunjucksEnv = new nunjucks.Environment(null, {
+            autoescape: false, // JSON 模板不需要 HTML 转义
+        });
+        this.registerNunjucksFilters();
+    }
+    /**
+     * 注册 Nunjucks 内置过滤器
+     * 替换原有的 Loader 和 Transformer 系统
+     */
+    registerNunjucksFilters() {
+        const self = this;
+        // 异步过滤器：读取文件或下载远程图片
+        // 用法: {{ imagePath | file | base64 | dataUri }}
+        // 支持：
+        // - 本地文件路径：读取文件内容
+        // - 远程 URL (http/https)：下载图片内容（解决防盗链问题）
+        // - data URI：直接返回
+        this.nunjucksEnv.addFilter('file', function (filePath, callback) {
+            // 检测常见错误：传入对象而不是字符串
+            if (filePath && typeof filePath === 'object') {
+                const obj = filePath;
+                const hasImageUrl = 'imageUrl' in obj || 'image_url' in obj || 'url' in obj;
+                if (hasImageUrl) {
+                    callback(new Error(`file filter received an object instead of a string. ` +
+                        `This usually happens when image_search results are passed directly. ` +
+                        `Solution: Use path property in input definition, e.g., ` +
+                        `{ type: 'reference', fieldName: 'images', path: '[*].imageUrl' }`));
+                    return;
+                }
+                callback(new Error(`file filter requires a string, got object: ${JSON.stringify(filePath).slice(0, 100)}`));
+                return;
+            }
+            if (!filePath || typeof filePath !== 'string') {
+                callback(null, filePath);
+                return;
+            }
+            // 如果已经是 data URI，直接返回
+            if (filePath.startsWith('data:')) {
+                callback(null, filePath);
+                return;
+            }
+            // 如果是远程 URL，下载图片（解决防盗链问题）
+            if (filePath.startsWith('http://') || filePath.startsWith('https://')) {
+                self.downloadRemoteImage(filePath)
+                    .then(result => {
+                    if (result === null) {
+                        // 下载失败，返回空字符串标记，模板中会过滤掉
+                        console.warn(`[ActionService] Skipping inaccessible image: ${filePath}`);
+                        callback(null, ''); // 空字符串会被模板过滤掉
+                    }
+                    else {
+                        callback(null, result);
+                    }
+                })
+                    .catch(err => callback(err));
+                return;
+            }
+            // 本地文件
+            self.loadFileForTemplate(filePath)
+                .then(result => callback(null, result))
+                .catch(err => callback(err));
+        }, true); // true = 异步过滤器
+        // 同步过滤器：base64 编码
+        this.nunjucksEnv.addFilter('base64', function (input) {
+            // 如果是 file 过滤器的输出对象 { buffer, mimeType }
+            if (input && typeof input === 'object' && 'buffer' in input) {
+                const obj = input;
+                return {
+                    base64: obj.buffer.toString('base64'),
+                    mimeType: obj.mimeType,
+                };
+            }
+            // 如果是 Buffer
+            if (Buffer.isBuffer(input)) {
+                return input.toString('base64');
+            }
+            // 如果是字符串（URL 或已处理的值），直接返回
+            if (typeof input === 'string') {
+                return input;
+            }
+            return input;
+        });
+        // 同步过滤器：生成 data URI
+        this.nunjucksEnv.addFilter('dataUri', function (input) {
+            // 如果是 base64 过滤器的输出对象 { base64, mimeType }
+            if (input && typeof input === 'object' && 'base64' in input) {
+                const obj = input;
+                return `data:${obj.mimeType};base64,${obj.base64}`;
+            }
+            // 如果是字符串（URL），直接返回
+            if (typeof input === 'string') {
+                return input;
+            }
+            return input;
+        });
+        // 异步过滤器：批量下载图片并转换为 data URI
+        // 用法: {{ referenceImages | fetchImages }}
+        // 输入: URL 字符串数组
+        // 输出: data URI 字符串数组（过滤掉无法下载的图片，最多 3 张）
+        const MAX_REFERENCE_IMAGES = 3;
+        this.nunjucksEnv.addFilter('fetchImages', function (urls, callback) {
+            if (!Array.isArray(urls)) {
+                callback(null, []);
+                return;
+            }
+            // 限制最多处理 MAX_REFERENCE_IMAGES 张图片，避免超时
+            const limitedUrls = urls.slice(0, MAX_REFERENCE_IMAGES);
+            if (urls.length > MAX_REFERENCE_IMAGES) {
+                console.log(`[ActionService] fetchImages: limiting to ${MAX_REFERENCE_IMAGES} images (received ${urls.length})`);
+            }
+            const downloadPromises = limitedUrls.map(async (url) => {
+                if (typeof url !== 'string' || !url) {
+                    return null;
+                }
+                // data URI 直接返回
+                if (url.startsWith('data:')) {
+                    return url;
+                }
+                // 远程 URL 尝试下载
+                if (url.startsWith('http://') || url.startsWith('https://')) {
+                    const result = await self.downloadRemoteImage(url);
+                    if (result) {
+                        const base64 = result.buffer.toString('base64');
+                        return `data:${result.mimeType};base64,${base64}`;
+                    }
+                    return null; // 下载失败
+                }
+                // 本地文件
+                try {
+                    const result = await self.loadFileForTemplate(url);
+                    const base64 = result.buffer.toString('base64');
+                    return `data:${result.mimeType};base64,${base64}`;
+                }
+                catch {
+                    console.warn(`[ActionService] Failed to load local file: ${url}`);
+                    return null;
+                }
+            });
+            Promise.all(downloadPromises)
+                .then(results => {
+                // 过滤掉 null（下载失败的图片）
+                const validUrls = results.filter((r) => r !== null);
+                console.log(`[ActionService] fetchImages: ${validUrls.length}/${limitedUrls.length} images successfully loaded`);
+                callback(null, validUrls);
+            })
+                .catch(err => callback(err));
+        }, true); // true = 异步过滤器
+    }
+    /**
+     * 加载文件（供 file 过滤器使用）
+     */
+    async loadFileForTemplate(filePath) {
+        const result = await this.fileLoader.load(filePath, { binary: true });
+        return {
+            buffer: Buffer.isBuffer(result.value) ? result.value : Buffer.from(result.value),
+            mimeType: result.mimeType,
+        };
+    }
+    /**
+     * 下载远程图片（解决防盗链问题）
+     * 通过本地代理下载，绕过 referer 检查
+     * 如果下载失败，返回 null 而不是抛出错误
+     */
+    async downloadRemoteImage(url) {
+        try {
+            const response = await fetch(url, {
+                headers: {
+                    // 模拟浏览器请求，绕过简单的防盗链检查
+                    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                    'Accept': 'image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8',
+                    'Accept-Language': 'en-US,en;q=0.9',
+                    'Referer': new URL(url).origin + '/',
+                },
+            });
+            if (!response.ok) {
+                console.warn(`[ActionService] Failed to download image (${response.status}): ${url}`);
+                return null; // 返回 null，让调用方决定如何处理
+            }
+            const arrayBuffer = await response.arrayBuffer();
+            const buffer = Buffer.from(arrayBuffer);
+            // 从 Content-Type 获取 MIME 类型，或根据 URL 猜测
+            let mimeType = response.headers.get('content-type') || 'image/jpeg';
+            // 移除 charset 等额外信息
+            if (mimeType.includes(';')) {
+                mimeType = mimeType.split(';')[0].trim();
+            }
+            return { buffer, mimeType };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[ActionService] Failed to download remote image: ${message}`);
+            return null; // 网络错误时也返回 null
+        }
+    }
+    /**
+     * 使用 Nunjucks 渲染模板
+     */
+    async renderTemplate(template, inputs) {
+        return new Promise((resolve, reject) => {
+            this.nunjucksEnv.renderString(template, inputs, (err, result) => {
+                if (err) {
+                    reject(new Error(`Template rendering error: ${err.message}`));
+                }
+                else {
+                    resolve(result || '');
+                }
+            });
+        });
+    }
+    async executeSync(actionType, context) {
+        switch (actionType.executionType) {
+            case 'llm_call':
+                return this.executeLLMCall(actionType, context);
+            case 'api_call':
+                return this.executeApiCall(actionType, context);
+            case 'http_request':
+                return this.executeHttpRequest(actionType, context);
+            case 'file_read':
+            case 'file_write':
+                return this.executeFileOperation(actionType, context);
+            case 'database_query':
+                return this.executeDatabaseQuery(actionType, context);
+            case 'shell_command':
+                return this.executeShellCommand(actionType, context);
+            default:
+                // 回退到 LLM 生成
+                return this.executeLLMCall(actionType, context);
+        }
+    }
+    async executeLLMCall(actionType, context) {
+        const result = await this.contentGeneration.generate(actionType.name, actionType.description, context.resolvedInputs, actionType.outputFields, this.defaultOptions);
+        return {
+            outputs: result.outputs,
+            reasoningContent: result.reasoningContent,
+        };
+    }
+    async executeApiCall(actionType, context) {
+        const apiConfig = actionType.apiConfig;
+        // 如果没有 apiConfig，回退到 LLM 生成（向后兼容）
+        if (!apiConfig) {
+            return this.executeLLMCall(actionType, context);
+        }
+        // 解析 URL 中的模板变量
+        const url = this.resolveUrlTemplate(apiConfig.url, context.resolvedInputs);
+        // 构建请求头（异步，支持 Template 表达式）
+        const headers = await this.buildHeaders(apiConfig, context.resolvedInputs);
+        // 构建请求体（异步，支持 Loader 表达式）
+        const body = await this.buildRequestBody(apiConfig, context.resolvedInputs);
+        // 构建 cookie 头
+        if (apiConfig.cookies && Object.keys(apiConfig.cookies).length > 0) {
+            const cookieHeader = Object.entries(apiConfig.cookies)
+                .map(([name, value]) => `${name}=${value}`)
+                .join('; ');
+            headers['Cookie'] = cookieHeader;
+        }
+        // 创建 AbortController 用于超时控制
+        const controller = new AbortController();
+        const timeoutMs = apiConfig.timeoutMs ?? 30000;
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetch(url, {
+                method: apiConfig.method ?? 'GET',
+                headers,
+                body,
+                signal: controller.signal,
+                redirect: apiConfig.followRedirects === false ? 'manual' : 'follow',
+            });
+            clearTimeout(timeoutId);
+            // 处理响应
+            const outputs = await this.processApiResponse(response, apiConfig, context.resolvedInputs);
+            return { outputs };
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new Error(`API call timeout after ${timeoutMs}ms: ${url}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * 解析 URL 中的模板变量
+     * 支持 ${variableName} 格式
+     */
+    resolveUrlTemplate(urlTemplate, inputs) {
+        return urlTemplate.replace(/\$\{(\w+)\}/g, (_match, varName) => {
+            const value = inputs[varName];
+            if (value === undefined || value === null) {
+                throw new Error(`Missing URL template variable: ${varName}`);
+            }
+            return encodeURIComponent(String(value));
+        });
+    }
+    /**
+     * 构建请求头（异步版本，支持 Nunjucks 模板）
+     */
+    async buildHeaders(apiConfig, inputs) {
+        const headers = {};
+        if (apiConfig.headers) {
+            const { type, values, template, base } = apiConfig.headers;
+            // 1. 先添加 base headers（优先级最低）
+            if (base) {
+                Object.assign(headers, base);
+            }
+            // 2. 根据 type 处理
+            if (type === 'static') {
+                // 静态模式：直接使用 values
+                if (values) {
+                    Object.assign(headers, values);
+                }
+            }
+            else if (type === 'template') {
+                // 模板模式：渲染 Nunjucks 模板
+                if (template) {
+                    const renderedHeaders = await this.renderTemplate(template, inputs);
+                    try {
+                        const parsedHeaders = JSON.parse(renderedHeaders);
+                        if (typeof parsedHeaders === 'object' && parsedHeaders !== null) {
+                            Object.assign(headers, parsedHeaders);
+                        }
+                        else {
+                            throw new Error('headers.template must render to a JSON object');
+                        }
+                    }
+                    catch (error) {
+                        if (error instanceof SyntaxError) {
+                            throw new Error(`headers.template must render to valid JSON: ${error.message}`);
+                        }
+                        throw error;
+                    }
+                }
+            }
+        }
+        // 如果有请求体且未指定 Content-Type，根据 contentType 设置
+        if (apiConfig.body) {
+            if (!headers['Content-Type']) {
+                switch (apiConfig.body.contentType) {
+                    case 'json':
+                    case 'template':
+                        headers['Content-Type'] = 'application/json';
+                        break;
+                    case 'form':
+                        headers['Content-Type'] = 'application/x-www-form-urlencoded';
+                        break;
+                    // raw 类型由用户自行设置 Content-Type
+                }
+            }
+        }
+        return headers;
+    }
+    /**
+     * 构建请求体（异步版本，支持 Loader 表达式）
+     */
+    async buildRequestBody(apiConfig, inputs) {
+        if (!apiConfig.body) {
+            return undefined;
+        }
+        const { contentType, rawField, template, includeFields, excludeFields } = apiConfig.body;
+        // raw 模式：使用指定字段的原始值
+        if (contentType === 'raw') {
+            if (!rawField) {
+                throw new Error('rawField is required when contentType is "raw"');
+            }
+            const value = inputs[rawField];
+            return typeof value === 'string' ? value : JSON.stringify(value);
+        }
+        // template 模式：使用 Nunjucks 模板引擎
+        if (contentType === 'template') {
+            if (!template) {
+                throw new Error('template is required when contentType is "template"');
+            }
+            return this.renderTemplate(template, inputs);
+        }
+        // 确定要包含的字段
+        let bodyData = {};
+        if (includeFields && includeFields.length > 0) {
+            // 只包含指定字段
+            for (const field of includeFields) {
+                if (field in inputs) {
+                    bodyData[field] = inputs[field];
+                }
+            }
+        }
+        else {
+            // 包含所有输入字段（排除以 _ 开头的内部字段）
+            bodyData = { ...inputs };
+            for (const key of Object.keys(bodyData)) {
+                if (key.startsWith('_')) {
+                    delete bodyData[key];
+                }
+            }
+        }
+        // 排除指定字段
+        if (excludeFields && excludeFields.length > 0) {
+            for (const field of excludeFields) {
+                delete bodyData[field];
+            }
+        }
+        // 根据 contentType 序列化
+        if (contentType === 'json') {
+            return JSON.stringify(bodyData);
+        }
+        else if (contentType === 'form') {
+            const params = new URLSearchParams();
+            for (const [key, value] of Object.entries(bodyData)) {
+                params.append(key, String(value));
+            }
+            return params.toString();
+        }
+        return undefined;
+    }
+    /**
+     * 处理 API 响应
+     */
+    async processApiResponse(response, apiConfig, inputs) {
+        const responseType = apiConfig.response?.type ?? 'json';
+        let responseData;
+        switch (responseType) {
+            case 'json':
+                responseData = await response.json();
+                break;
+            case 'text':
+                responseData = await response.text();
+                break;
+            case 'binary':
+                responseData = await response.arrayBuffer();
+                break;
+        }
+        // 检查 API 是否返回了错误响应
+        if (responseData && typeof responseData === 'object' && 'error' in responseData) {
+            const errorResponse = responseData;
+            const errorMessage = errorResponse.error?.message || JSON.stringify(errorResponse.error);
+            throw new Error(`API returned error: ${errorMessage}`);
+        }
+        // 基础输出
+        const outputs = {
+            _status: response.status,
+            _statusText: response.statusText,
+            _headers: Object.fromEntries(response.headers.entries()),
+        };
+        // 检查是否配置了 saveToFile
+        const saveToFileConfig = apiConfig.response?.saveToFile;
+        if (saveToFileConfig?.enabled) {
+            const saveResult = await this.saveResponseDataToFile(responseData, saveToFileConfig, inputs);
+            // 返回文件路径和相关信息，不返回原始数据
+            const outputField = saveToFileConfig.outputField ?? 'filePath';
+            outputs[outputField] = saveResult.filePath;
+            outputs.bytesWritten = saveResult.bytesWritten;
+            outputs.success = true;
+            return outputs;
+        }
+        // 如果配置了字段提取
+        if (apiConfig.response?.extract && typeof responseData === 'object' && responseData !== null) {
+            for (const [outputField, jsonPath] of Object.entries(apiConfig.response.extract)) {
+                outputs[outputField] = this.extractByPath(responseData, jsonPath);
+            }
+        }
+        else {
+            // 没有配置提取时，直接返回响应数据
+            outputs.response = responseData;
+        }
+        return outputs;
+    }
+    /**
+     * 将响应数据保存到文件
+     * 用于处理大型响应（如图片、视频），避免超出 Temporal payload 限制
+     */
+    async saveResponseDataToFile(responseData, config, inputs) {
+        // 获取保存路径
+        const targetPath = inputs[config.pathField];
+        if (!targetPath) {
+            throw new Error(`saveToFile.pathField "${config.pathField}" not found in inputs`);
+        }
+        // 解析并验证文件路径
+        const fullPath = this.resolveFilePath(targetPath);
+        // 提取要保存的数据
+        let dataToSave = responseData;
+        if (config.dataPath) {
+            dataToSave = this.extractByPath(responseData, config.dataPath);
+            if (dataToSave === undefined) {
+                throw new Error(`Could not extract data from response using path: ${config.dataPath}`);
+            }
+        }
+        // 确定数据格式并转换为 Buffer
+        const buffer = this.convertToBuffer(dataToSave, config.dataFormat);
+        // 确保目录存在
+        const dir = path.dirname(fullPath);
+        await fs.mkdir(dir, { recursive: true });
+        // 写入文件
+        await fs.writeFile(fullPath, buffer);
+        return {
+            filePath: fullPath,
+            bytesWritten: buffer.length,
+        };
+    }
+    /**
+     * 将数据转换为 Buffer
+     * 支持多种数据格式
+     */
+    convertToBuffer(data, format = 'auto') {
+        // 预处理：如果数据是对象且包含 url 字段（如 { url: "data:..." }），提取 url
+        let processedData = data;
+        if (typeof data === 'object' && data !== null && 'url' in data) {
+            processedData = data.url;
+        }
+        // 自动检测格式
+        if (format === 'auto') {
+            if (typeof processedData === 'string') {
+                // 检查是否是 base64 data URI
+                if (processedData.startsWith('data:')) {
+                    format = 'base64';
+                }
+                else if (this.looksLikeBase64(processedData)) {
+                    format = 'base64';
+                }
+                else {
+                    format = 'text';
+                }
+            }
+            else if (processedData instanceof ArrayBuffer || Buffer.isBuffer(processedData)) {
+                format = 'binary';
+            }
+            else {
+                format = 'json';
+            }
+        }
+        switch (format) {
+            case 'base64': {
+                // 处理对象包装的情况（如 { url: "data:..." }）
+                let strData;
+                if (typeof processedData === 'string') {
+                    strData = processedData;
+                }
+                else if (typeof processedData === 'object' && processedData !== null) {
+                    // 尝试从对象中提取字符串
+                    const obj = processedData;
+                    if (typeof obj.url === 'string') {
+                        strData = obj.url;
+                    }
+                    else if (typeof obj.image_url === 'string') {
+                        strData = obj.image_url;
+                    }
+                    else {
+                        throw new Error('base64 format requires string data or object with url/image_url field');
+                    }
+                }
+                else {
+                    throw new Error('base64 format requires string data');
+                }
+                // 处理 data URI 格式
+                if (strData.startsWith('data:')) {
+                    const base64Data = strData.split(',')[1];
+                    if (!base64Data) {
+                        throw new Error('Invalid data URI format');
+                    }
+                    return Buffer.from(base64Data, 'base64');
+                }
+                return Buffer.from(strData, 'base64');
+            }
+            case 'binary': {
+                if (processedData instanceof ArrayBuffer) {
+                    return Buffer.from(processedData);
+                }
+                if (Buffer.isBuffer(processedData)) {
+                    return processedData;
+                }
+                throw new Error('binary format requires ArrayBuffer or Buffer data');
+            }
+            case 'text': {
+                if (typeof processedData === 'string') {
+                    return Buffer.from(processedData, 'utf-8');
+                }
+                return Buffer.from(String(processedData), 'utf-8');
+            }
+            case 'json': {
+                return Buffer.from(JSON.stringify(processedData, null, 2), 'utf-8');
+            }
+            default:
+                throw new Error(`Unknown data format: ${format}`);
+        }
+    }
+    /**
+     * 检查字符串是否看起来像 base64 编码
+     */
+    looksLikeBase64(str) {
+        // 简单检查：长度较长且只包含 base64 字符
+        if (str.length < 100)
+            return false;
+        const base64Regex = /^[A-Za-z0-9+/=]+$/;
+        return base64Regex.test(str.slice(0, 100));
+    }
+    /**
+     * 从对象中按路径提取值
+     * 支持点号分隔路径和数组索引，如:
+     * - "data.results"
+     * - "meta.total"
+     * - "choices.0.message" (数字作为数组索引)
+     * - "items[0].name" (方括号数组索引)
+     */
+    extractByPath(obj, path) {
+        // 将 [0] 格式转换为 .0 格式，统一处理
+        const normalizedPath = path.replace(/\[(\d+)\]/g, '.$1');
+        const parts = normalizedPath.split('.');
+        let current = obj;
+        for (const part of parts) {
+            if (current === null || current === undefined) {
+                return undefined;
+            }
+            if (typeof current !== 'object') {
+                return undefined;
+            }
+            // 检查是否是数组索引
+            const index = parseInt(part, 10);
+            if (!isNaN(index) && Array.isArray(current)) {
+                current = current[index];
+            }
+            else {
+                current = current[part];
+            }
+        }
+        return current;
+    }
+    async executeHttpRequest(_actionType, context) {
+        // HTTP 请求逻辑
+        const url = context.resolvedInputs.url;
+        const method = context.resolvedInputs.method ?? 'GET';
+        const body = context.resolvedInputs.body;
+        const response = await fetch(url, {
+            method,
+            headers: { 'Content-Type': 'application/json' },
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        const data = await response.json();
+        return { outputs: { response: data, status: response.status } };
+    }
+    async executeFileOperation(actionType, context) {
+        const { resolvedInputs } = context;
+        // 获取文件路径
+        const filePath = resolvedInputs.filePath;
+        const filename = resolvedInputs.filename;
+        const targetPath = filePath ?? filename;
+        if (!targetPath) {
+            throw new Error('File operation requires filePath or filename input');
+        }
+        // 构建完整路径并验证安全性
+        const fullPath = this.resolveFilePath(targetPath);
+        if (actionType.executionType === 'file_write') {
+            return this.executeFileWrite(fullPath, resolvedInputs);
+        }
+        else if (actionType.executionType === 'file_read') {
+            return this.executeFileRead(fullPath, resolvedInputs);
+        }
+        throw new Error(`Unknown file operation: ${actionType.executionType}`);
+    }
+    /**
+     * 解析并验证文件路径
+     */
+    resolveFilePath(targetPath) {
+        // 如果是绝对路径，直接使用；否则相对于 baseDir
+        const fullPath = path.isAbsolute(targetPath)
+            ? targetPath
+            : path.resolve(this.fileConfig.baseDir, targetPath);
+        // 安全检查：确保路径在 baseDir 内（防止路径遍历攻击）
+        const normalizedPath = path.normalize(fullPath);
+        const normalizedBase = path.normalize(this.fileConfig.baseDir);
+        if (!normalizedPath.startsWith(normalizedBase)) {
+            throw new Error(`File path must be within base directory: ${this.fileConfig.baseDir}`);
+        }
+        // 检查文件扩展名
+        if (this.fileConfig.allowedExtensions && this.fileConfig.allowedExtensions.length > 0) {
+            const ext = path.extname(normalizedPath).toLowerCase();
+            if (!this.fileConfig.allowedExtensions.includes(ext)) {
+                throw new Error(`File extension not allowed: ${ext}. Allowed: ${this.fileConfig.allowedExtensions.join(', ')}`);
+            }
+        }
+        return normalizedPath;
+    }
+    /**
+     * 执行文件写入
+     */
+    async executeFileWrite(fullPath, inputs) {
+        const content = inputs.content;
+        const data = inputs.data;
+        // 确定要写入的内容
+        let writeContent;
+        if (typeof content === 'string') {
+            writeContent = content;
+        }
+        else if (data !== undefined) {
+            writeContent = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+        }
+        else {
+            throw new Error('File write requires content or data input');
+        }
+        // 检查内容大小
+        const contentSize = Buffer.byteLength(writeContent, 'utf8');
+        if (contentSize > this.fileConfig.maxFileSize) {
+            throw new Error(`Content size (${contentSize} bytes) exceeds maximum allowed (${this.fileConfig.maxFileSize} bytes)`);
+        }
+        // 确保目录存在
+        const dir = path.dirname(fullPath);
+        await fs.mkdir(dir, { recursive: true });
+        // 写入文件
+        const encoding = inputs.encoding ?? 'utf8';
+        const append = inputs.append === true;
+        if (append) {
+            await fs.appendFile(fullPath, writeContent, { encoding });
+        }
+        else {
+            await fs.writeFile(fullPath, writeContent, { encoding });
+        }
+        // 获取文件信息
+        const stats = await fs.stat(fullPath);
+        return {
+            outputs: {
+                success: true,
+                filePath: fullPath,
+                bytesWritten: contentSize,
+                fileSize: stats.size,
+            },
+        };
+    }
+    /**
+     * 执行文件读取
+     */
+    async executeFileRead(fullPath, inputs) {
+        // 检查文件是否存在
+        try {
+            await fs.access(fullPath);
+        }
+        catch {
+            throw new Error(`File not found: ${fullPath}`);
+        }
+        // 获取文件信息
+        const stats = await fs.stat(fullPath);
+        // 检查文件大小
+        if (stats.size > this.fileConfig.maxFileSize) {
+            throw new Error(`File size (${stats.size} bytes) exceeds maximum allowed (${this.fileConfig.maxFileSize} bytes)`);
+        }
+        // 读取文件
+        const encoding = inputs.encoding ?? 'utf8';
+        const content = await fs.readFile(fullPath, { encoding });
+        // 尝试解析 JSON（如果请求）
+        let parsedData = undefined;
+        if (inputs.parseJson === true) {
+            try {
+                parsedData = JSON.parse(content);
+            }
+            catch {
+                // 解析失败，保持 undefined
+            }
+        }
+        return {
+            outputs: {
+                success: true,
+                filePath: fullPath,
+                content,
+                data: parsedData,
+                fileSize: stats.size,
+            },
+        };
+    }
+    async executeDatabaseQuery(_actionType, _context) {
+        // 数据库查询逻辑（需要注入数据库连接）
+        // TODO: 注入数据库连接并实现查询逻辑
+        return { outputs: { rows: [] } };
+    }
+    async executeShellCommand(_actionType, _context) {
+        // Shell 命令逻辑（需要根据实际环境实现）
+        // TODO: 根据安全策略实现 shell 命令执行
+        return { outputs: { stdout: '', stderr: '', exitCode: 0 } };
+    }
+    async submitAsyncTask(actionType, context) {
+        const asyncMode = actionType.asyncMode;
+        // 验证异步配置
+        if (!asyncMode?.statusCheck?.url) {
+            throw new Error(`Async action "${actionType.id}" requires asyncMode.statusCheck.url configuration. ` +
+                `Please configure the status check URL for polling task status.`);
+        }
+        // 使用 apiConfig 提交任务
+        if (!actionType.apiConfig) {
+            throw new Error(`Async action "${actionType.id}" requires apiConfig for task submission`);
+        }
+        // 调用现有的 executeApiCall 提交任务
+        const submitResult = await this.executeApiCall(actionType, context);
+        // 从响应中提取 taskId
+        const taskIdPath = asyncMode.taskIdPath ?? 'taskId';
+        const taskId = this.extractByPath(submitResult.outputs.response ?? submitResult.outputs, taskIdPath);
+        if (!taskId || typeof taskId !== 'string') {
+            throw new Error(`Failed to extract taskId from response using path "${taskIdPath}". ` +
+                `Response: ${JSON.stringify(submitResult.outputs)}`);
+        }
+        // 保存任务上下文
+        // 从新结构中提取 headers 用于后续请求
+        const headersConfig = actionType.apiConfig.headers;
+        let resolvedHeaders;
+        if (headersConfig) {
+            // 合并 base 和 values/template 渲染结果
+            // 由于 checkTaskStatus/getTaskResult 需要同步使用，这里只保存静态值
+            resolvedHeaders = { ...headersConfig.base };
+            if (headersConfig.type === 'static' && headersConfig.values) {
+                Object.assign(resolvedHeaders, headersConfig.values);
+            }
+            // 注意：template 类型需要动态渲染，这里暂时使用 base
+            // 如果 statusCheck/resultFetch 需要动态 headers，应在各自配置中定义
+        }
+        this.asyncTaskContexts.set(taskId, {
+            taskId,
+            asyncMode,
+            headers: resolvedHeaders,
+            inputs: context.resolvedInputs,
+        });
+        return taskId;
+    }
+    async checkTaskStatus(taskId) {
+        const ctx = this.asyncTaskContexts.get(taskId);
+        if (!ctx) {
+            throw new Error(`Task context not found for taskId: ${taskId}. The task may not have been submitted through this service instance.`);
+        }
+        const statusCheck = ctx.asyncMode.statusCheck;
+        // 解析 URL 模板
+        const url = this.resolveAsyncUrlTemplate(statusCheck.url, taskId, ctx.inputs);
+        // 合并请求头
+        const headers = {
+            ...ctx.headers,
+            ...statusCheck.headers,
+        };
+        // 发起状态检查请求
+        const response = await fetch(url, {
+            method: statusCheck.method ?? 'GET',
+            headers,
+        });
+        if (!response.ok) {
+            throw new Error(`Status check failed: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        // 保存响应用于后续结果提取
+        ctx.lastStatusResponse = data;
+        // 提取状态信息
+        const extract = statusCheck.extract;
+        const statusValue = this.extractByPath(data, extract.statusPath ?? 'status');
+        // 规范化状态值比较
+        const completedValues = this.normalizeStatusValues(extract.completedValues ?? 'completed');
+        const failedValues = this.normalizeStatusValues(extract.failedValues ?? 'failed');
+        const statusStr = String(statusValue).toLowerCase();
+        const completed = completedValues.some(v => v.toLowerCase() === statusStr);
+        const failed = failedValues.some(v => v.toLowerCase() === statusStr);
+        // 提取错误信息
+        let error;
+        if (failed && extract.errorPath) {
+            const errorValue = this.extractByPath(data, extract.errorPath);
+            error = errorValue ? String(errorValue) : undefined;
+        }
+        // 提取进度
+        let progress;
+        if (extract.progressPath) {
+            const progressValue = this.extractByPath(data, extract.progressPath);
+            if (typeof progressValue === 'number') {
+                progress = progressValue;
+            }
+        }
+        return { completed, failed, error, progress };
+    }
+    async getTaskResult(taskId) {
+        const ctx = this.asyncTaskContexts.get(taskId);
+        if (!ctx) {
+            throw new Error(`Task context not found for taskId: ${taskId}. The task may not have been submitted through this service instance.`);
+        }
+        const resultFetch = ctx.asyncMode.resultFetch;
+        // 情况 1: 有独立的结果获取 URL
+        if (resultFetch?.url) {
+            const url = this.resolveAsyncUrlTemplate(resultFetch.url, taskId, ctx.inputs);
+            const headers = {
+                ...ctx.headers,
+                ...resultFetch.headers,
+            };
+            const response = await fetch(url, {
+                method: resultFetch.method ?? 'GET',
+                headers,
+            });
+            if (!response.ok) {
+                throw new Error(`Result fetch failed: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            // 应用结果提取映射
+            if (resultFetch.extract) {
+                return { outputs: this.extractMultipleFields(data, resultFetch.extract) };
+            }
+            return { outputs: data };
+        }
+        // 情况 2: 从最后一次状态检查响应中提取结果
+        if (ctx.lastStatusResponse) {
+            const extractConfig = resultFetch?.extractFromStatus;
+            if (extractConfig) {
+                return { outputs: this.extractMultipleFields(ctx.lastStatusResponse, extractConfig) };
+            }
+            // 使用整个状态响应作为结果
+            return { outputs: ctx.lastStatusResponse };
+        }
+        throw new Error('No result available: neither result URL nor status response found');
+    }
+    /**
+     * 解析异步 URL 模板
+     * 支持 ${taskId} 和 ${fieldName} 变量
+     */
+    resolveAsyncUrlTemplate(urlTemplate, taskId, inputs) {
+        return urlTemplate.replace(/\$\{(\w+)\}/g, (_match, varName) => {
+            if (varName === 'taskId') {
+                return encodeURIComponent(taskId);
+            }
+            const value = inputs[varName];
+            if (value === undefined || value === null) {
+                throw new Error(`Missing URL template variable: ${varName}`);
+            }
+            return encodeURIComponent(String(value));
+        });
+    }
+    /**
+     * 规范化状态值为数组
+     */
+    normalizeStatusValues(values) {
+        return Array.isArray(values) ? values : [values];
+    }
+    /**
+     * 从对象中提取多个字段
+     */
+    extractMultipleFields(data, extract) {
+        const result = {};
+        for (const [outputField, jsonPath] of Object.entries(extract)) {
+            result[outputField] = this.extractByPath(data, jsonPath);
+        }
+        return result;
+    }
+    /**
+     * 清理已完成的异步任务上下文
+     * 防止内存泄漏
+     */
+    cleanupAsyncTaskContext(taskId) {
+        this.asyncTaskContexts.delete(taskId);
+    }
+}
+//# sourceMappingURL=actionService.js.map