koishi-plugin-media-luna 0.0.1

package/lib/middlewares/builtin/storage.js

@@ -0,0 +1,715 @@
+// 存储中间件 - 将输入文件和生成结果缓存到外部存储
+import { createHash } from 'crypto';
+import { promises as fs } from 'fs';
+import { join, dirname } from 'path';
+/**
+ * 存储配置字段
+ */
+export const storageConfigFields = [
+    {
+        key: 'backend',
+        label: '存储后端',
+        type: 'select',
+        default: 'none',
+        options: [
+            { label: '不使用（保留原始 URL）', value: 'none' },
+            { label: 'Koishi 资源服务（推荐）', value: 'koishi' },
+            { label: '本地缓存（自定义）', value: 'local' },
+            { label: 'S3 兼容存储', value: 's3' },
+            { label: 'WebDAV', value: 'webdav' }
+        ],
+        description: '选择存储后端用于缓存生成结果。推荐使用 Koishi 资源服务，需安装 assets-local 等 assets 插件。'
+    },
+    // 本地缓存配置（仅当选择 local 时显示）
+    {
+        key: 'localCacheDir',
+        label: '缓存目录',
+        type: 'text',
+        default: 'data/media-luna/assets',
+        placeholder: 'data/media-luna/assets',
+        description: '本地缓存文件存储目录（相对于 Koishi 根目录）',
+        showWhen: { field: 'backend', value: 'local' }
+    },
+    {
+        key: 'localMaxSizeMB',
+        label: '最大容量 (MB)',
+        type: 'number',
+        default: 1024,
+        placeholder: '1024',
+        description: '本地缓存最大容量（超出时自动清理旧文件）',
+        showWhen: { field: 'backend', value: 'local' }
+    },
+    {
+        key: 'localPublicPath',
+        label: '公开访问路径',
+        type: 'text',
+        default: '/media-luna/assets',
+        placeholder: '/media-luna/assets',
+        description: '通过 Koishi 内置 HTTP 服务访问缓存文件的 URL 路径',
+        showWhen: { field: 'backend', value: 'local' }
+    },
+    {
+        key: 'localPublicBaseUrl',
+        label: '公开访问地址',
+        type: 'text',
+        placeholder: 'http://your-domain.com:5140',
+        description: '对外访问的 URL 前缀（默认自动检测，如需暴露到公网请手动配置）',
+        showWhen: { field: 'backend', value: 'local' }
+    },
+    // S3 配置
+    {
+        key: 's3Endpoint',
+        label: 'S3 端点',
+        type: 'text',
+        placeholder: 'https://s3.amazonaws.com',
+        description: 'S3 兼容服务端点地址',
+        showWhen: { field: 'backend', value: 's3' }
+    },
+    {
+        key: 's3Region',
+        label: 'S3 区域',
+        type: 'text',
+        default: 'us-east-1',
+        placeholder: 'us-east-1',
+        showWhen: { field: 'backend', value: 's3' }
+    },
+    {
+        key: 's3AccessKeyId',
+        label: 'Access Key ID',
+        type: 'text',
+        showWhen: { field: 'backend', value: 's3' }
+    },
+    {
+        key: 's3SecretAccessKey',
+        label: 'Secret Access Key',
+        type: 'password',
+        showWhen: { field: 'backend', value: 's3' }
+    },
+    {
+        key: 's3Bucket',
+        label: 'Bucket 名称',
+        type: 'text',
+        placeholder: 'my-bucket',
+        showWhen: { field: 'backend', value: 's3' }
+    },
+    {
+        key: 's3PublicBaseUrl',
+        label: '公开访问 URL',
+        type: 'text',
+        placeholder: 'https://cdn.example.com',
+        description: 'CDN 或直接访问的 URL 前缀（可选）',
+        showWhen: { field: 'backend', value: 's3' }
+    },
+    {
+        key: 's3ForcePathStyle',
+        label: '强制路径风格',
+        type: 'boolean',
+        default: false,
+        description: '使用路径风格而非虚拟主机风格（适用于 MinIO 等）',
+        showWhen: { field: 'backend', value: 's3' }
+    },
+    {
+        key: 's3Acl',
+        label: 'ACL 权限',
+        type: 'select',
+        default: 'public-read',
+        options: [
+            { label: '公开读取', value: 'public-read' },
+            { label: '私有', value: 'private' }
+        ],
+        showWhen: { field: 'backend', value: 's3' }
+    },
+    // WebDAV 配置
+    {
+        key: 'webdavEndpoint',
+        label: 'WebDAV 端点',
+        type: 'text',
+        placeholder: 'https://dav.example.com/files',
+        description: 'WebDAV 服务根地址',
+        showWhen: { field: 'backend', value: 'webdav' }
+    },
+    {
+        key: 'webdavUsername',
+        label: '用户名',
+        type: 'text',
+        showWhen: { field: 'backend', value: 'webdav' }
+    },
+    {
+        key: 'webdavPassword',
+        label: '密码',
+        type: 'password',
+        showWhen: { field: 'backend', value: 'webdav' }
+    },
+    {
+        key: 'webdavBasePath',
+        label: '基础路径',
+        type: 'text',
+        placeholder: 'media-luna',
+        description: '上传文件的目录路径（可选）',
+        showWhen: { field: 'backend', value: 'webdav' }
+    },
+    {
+        key: 'webdavPublicBaseUrl',
+        label: '公开访问 URL',
+        type: 'text',
+        placeholder: 'https://files.example.com',
+        description: '对外访问的 URL 前缀（若与端点不同）',
+        showWhen: { field: 'backend', value: 'webdav' }
+    }
+];
+// ============ S3 上传实现 ============
+import { createHmac } from 'crypto';
+function toAmzDate(d) {
+    const pad = (n, w = 2) => n.toString().padStart(w, '0');
+    return (d.getUTCFullYear().toString() +
+        pad(d.getUTCMonth() + 1) +
+        pad(d.getUTCDate()) +
+        'T' +
+        pad(d.getUTCHours()) +
+        pad(d.getUTCMinutes()) +
+        pad(d.getUTCSeconds()) +
+        'Z');
+}
+function sha256Hex(data) {
+    return createHash('sha256').update(data).digest('hex');
+}
+function hmac(key, data) {
+    return createHmac('sha256', key).update(data, 'utf8').digest();
+}
+function hmacHex(key, data) {
+    return createHmac('sha256', key).update(data, 'utf8').digest('hex');
+}
+function getSignatureKey(secretKey, dateStamp, regionName, serviceName) {
+    const kDate = hmac('AWS4' + secretKey, dateStamp);
+    const kRegion = hmac(kDate, regionName);
+    const kService = hmac(kRegion, serviceName);
+    return hmac(kService, 'aws4_request');
+}
+function trimSpaces(str) {
+    return str.replace(/\s+/g, ' ').trim();
+}
+function encodeKey(key) {
+    return key.split('/').map(encodeURIComponent).join('/');
+}
+function joinUrl(base, key) {
+    const b = base.replace(/\/$/, '');
+    return `${b}/${encodeKey(key)}`;
+}
+async function uploadToS3(buffer, filename, mime, config) {
+    const bucket = config.s3Bucket;
+    const region = config.s3Region || 'us-east-1';
+    const accessKeyId = config.s3AccessKeyId;
+    const secretAccessKey = config.s3SecretAccessKey;
+    if (!bucket)
+        throw new Error('S3 缺少 bucket 配置');
+    if (!accessKeyId || !secretAccessKey)
+        throw new Error('S3 需提供访问凭证');
+    const now = new Date();
+    const amzDate = toAmzDate(now);
+    const dateStamp = amzDate.slice(0, 8);
+    const key = filename;
+    const hostInfo = buildS3HostAndPath(config, key);
+    const { host, url, canonicalUri } = hostInfo;
+    const payloadHash = sha256Hex(buffer);
+    const headers = {
+        'host': host,
+        'x-amz-content-sha256': payloadHash,
+        'x-amz-date': amzDate,
+    };
+    if (mime)
+        headers['content-type'] = mime;
+    if (config.s3Acl)
+        headers['x-amz-acl'] = config.s3Acl;
+    const signedHeaders = Object.keys(headers)
+        .map(k => k.toLowerCase())
+        .sort()
+        .join(';');
+    const canonicalHeaders = Object.keys(headers)
+        .map(k => k.toLowerCase())
+        .sort()
+        .map(k => `${k}:${trimSpaces(String(headers[k]))}\n`)
+        .join('');
+    const canonicalRequest = [
+        'PUT',
+        canonicalUri,
+        '',
+        canonicalHeaders,
+        signedHeaders,
+        payloadHash,
+    ].join('\n');
+    const algorithm = 'AWS4-HMAC-SHA256';
+    const credentialScope = `${dateStamp}/${region}/s3/aws4_request`;
+    const stringToSign = [
+        algorithm,
+        amzDate,
+        credentialScope,
+        sha256Hex(Buffer.from(canonicalRequest, 'utf8')),
+    ].join('\n');
+    const signingKey = getSignatureKey(secretAccessKey, dateStamp, region, 's3');
+    const signature = hmacHex(signingKey, stringToSign);
+    const authorization = `${algorithm} Credential=${accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+    const reqHeaders = { ...headers, Authorization: authorization };
+    const resp = await fetch(url, { method: 'PUT', headers: reqHeaders, body: new Uint8Array(buffer) });
+    if (!resp.ok)
+        throw new Error(`S3 上传失败: ${resp.status}`);
+    const publicUrl = config.s3PublicBaseUrl
+        ? joinUrl(config.s3PublicBaseUrl, key)
+        : url;
+    return { url: publicUrl, key };
+}
+function buildS3HostAndPath(config, key) {
+    let base;
+    if (config.s3Endpoint) {
+        base = new URL(config.s3Endpoint);
+    }
+    else {
+        base = new URL(`https://s3.${config.s3Region || 'us-east-1'}.amazonaws.com`);
+    }
+    const bucket = config.s3Bucket;
+    const isIp = /^\d{1,3}(?:\.\d{1,3}){3}$/.test(base.hostname);
+    const hasPort = !!base.port;
+    const isLocal = base.hostname === 'localhost';
+    const preferPath = isIp || hasPort || isLocal;
+    const usePath = !!config.s3ForcePathStyle || preferPath;
+    const hostname = base.hostname;
+    const port = base.port ? `:${base.port}` : '';
+    let host = hostname + port;
+    let path = '';
+    if (usePath) {
+        path = `/${bucket}/${encodeKey(key)}`;
+    }
+    else {
+        host = `${bucket}.${hostname}${port}`;
+        path = `/${encodeKey(key)}`;
+    }
+    const url = `${base.protocol}//${host}${path}`;
+    const canonicalUri = path;
+    return { host, url, canonicalUri };
+}
+function b64(str) {
+    return Buffer.from(str, 'utf8').toString('base64');
+}
+function trimSlash(s) {
+    return s.replace(/\/+$/, '');
+}
+function encodePath(path) {
+    return path.split('/').map(encodeURIComponent).join('/');
+}
+async function ensureWebDavBasePath(config) {
+    const base = (config.webdavBasePath || '').replace(/^\/+|\/+$/g, '');
+    if (!base)
+        return;
+    const segments = base.split('/').filter(Boolean);
+    let current = '';
+    for (const seg of segments) {
+        current = current ? `${current}/${seg}` : seg;
+        const url = `${trimSlash(config.webdavEndpoint)}/${encodePath(current)}`;
+        try {
+            await fetch(url, {
+                method: 'MKCOL',
+                headers: { 'Authorization': `Basic ${b64(`${config.webdavUsername}:${config.webdavPassword}`)}` }
+            });
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+}
+async function uploadToWebDav(buffer, filename, mime, config) {
+    if (!config.webdavEndpoint || !config.webdavUsername || !config.webdavPassword) {
+        throw new Error('WebDAV 缺少必要配置');
+    }
+    await ensureWebDavBasePath(config);
+    const remotePath = config.webdavBasePath
+        ? `${config.webdavBasePath.replace(/\/+$/, '')}/${filename}`
+        : filename;
+    const url = `${trimSlash(config.webdavEndpoint)}/${encodePath(remotePath)}`;
+    const headers = {
+        'Authorization': `Basic ${b64(`${config.webdavUsername}:${config.webdavPassword}`)}`,
+    };
+    if (mime)
+        headers['Content-Type'] = mime;
+    const res = await fetch(url, { method: 'PUT', headers: headers, body: new Uint8Array(buffer) });
+    if (!res.ok)
+        throw new Error(`WebDAV 上传失败: ${res.status}`);
+    const publicUrl = config.webdavPublicBaseUrl
+        ? `${trimSlash(config.webdavPublicBaseUrl)}/${encodePath(remotePath)}`
+        : url;
+    return { url: publicUrl, key: remotePath };
+}
+// 本地缓存上下文（用于存储 ctx 和 baseUrl）
+let localStorageCtx = null;
+let localStorageBaseUrl = null;
+/**
+ * 初始化本地存储 baseUrl 检测
+ * 注意：HTTP 路由由 asset-cache.service 统一注册 (/media-luna/assets/*)
+ */
+export function initLocalStorage(ctx, logger) {
+    localStorageCtx = ctx;
+    // 监听 server 事件获取 baseUrl
+    ctx.on('server/ready', () => {
+        const server = ctx.get('server');
+        if (server) {
+            // 获取服务器配置的端口
+            const port = server.config?.port || 5140;
+            const host = server.config?.host || 'localhost';
+            localStorageBaseUrl = `http://${host === '0.0.0.0' ? 'localhost' : host}:${port}`;
+            logger.info(`Local storage base URL: ${localStorageBaseUrl}`);
+        }
+    });
+}
+/**
+ * 获取本地存储的公开 URL
+ */
+function getLocalPublicUrl(config, relativePath) {
+    const publicPath = config.localPublicPath || '/media-luna/assets';
+    // 优先使用用户配置的 baseUrl，否则使用自动检测的
+    const baseUrl = config.localPublicBaseUrl || localStorageBaseUrl || '';
+    return `${baseUrl}${publicPath}/${relativePath}`;
+}
+/**
+ * 获取缓存统计信息
+ */
+export async function getLocalCacheStats(config) {
+    const cacheDir = config.localCacheDir || 'data/media-luna/assets';
+    const maxSizeMB = config.localMaxSizeMB || 1024;
+    const fullCacheDir = join(process.cwd(), cacheDir);
+    let totalFiles = 0;
+    let totalSize = 0;
+    try {
+        await countFilesRecursive(fullCacheDir, (size) => {
+            totalFiles++;
+            totalSize += size;
+        });
+    }
+    catch {
+        // 目录不存在
+    }
+    return {
+        totalFiles,
+        totalSizeMB: totalSize / (1024 * 1024),
+        maxSizeMB
+    };
+}
+async function countFilesRecursive(dir, callback) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await countFilesRecursive(fullPath, callback);
+        }
+        else {
+            const stat = await fs.stat(fullPath);
+            callback(stat.size);
+        }
+    }
+}
+/**
+ * 清理本地缓存
+ */
+export async function clearLocalCache(config) {
+    const cacheDir = config.localCacheDir || 'data/media-luna/assets';
+    const fullCacheDir = join(process.cwd(), cacheDir);
+    try {
+        await fs.rm(fullCacheDir, { recursive: true, force: true });
+        await fs.mkdir(fullCacheDir, { recursive: true });
+    }
+    catch {
+        // 忽略错误
+    }
+}
+/**
+ * 自动清理超出容量的旧文件
+ */
+async function autoCleanup(config, logger) {
+    const cacheDir = config.localCacheDir || 'data/media-luna/assets';
+    const maxSizeMB = config.localMaxSizeMB || 1024;
+    const maxSizeBytes = maxSizeMB * 1024 * 1024;
+    const fullCacheDir = join(process.cwd(), cacheDir);
+    const files = [];
+    try {
+        await collectFilesRecursive(fullCacheDir, files);
+    }
+    catch {
+        return;
+    }
+    // 按修改时间排序（旧的在前）
+    files.sort((a, b) => a.mtime - b.mtime);
+    let totalSize = files.reduce((sum, f) => sum + f.size, 0);
+    // 删除旧文件直到总大小低于限制
+    while (totalSize > maxSizeBytes && files.length > 0) {
+        const oldest = files.shift();
+        try {
+            await fs.unlink(oldest.path);
+            totalSize -= oldest.size;
+            logger.debug(`Auto-cleaned old cache file: ${oldest.path}`);
+        }
+        catch {
+            // 忽略删除错误
+        }
+    }
+}
+async function collectFilesRecursive(dir, files) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await collectFilesRecursive(fullPath, files);
+        }
+        else {
+            const stat = await fs.stat(fullPath);
+            files.push({ path: fullPath, mtime: stat.mtimeMs, size: stat.size });
+        }
+    }
+}
+async function uploadToLocal(buffer, filename, mime, config, logger) {
+    const cacheDir = config.localCacheDir || 'data/media-luna/assets';
+    const fullCacheDir = join(process.cwd(), cacheDir);
+    const filePath = join(fullCacheDir, filename);
+    // 确保目录存在
+    await fs.mkdir(dirname(filePath), { recursive: true });
+    // 写入文件
+    await fs.writeFile(filePath, buffer);
+    // 自动清理
+    await autoCleanup(config, logger);
+    const publicUrl = getLocalPublicUrl(config, filename);
+    return {
+        url: publicUrl,
+        key: filename,
+        filePath
+    };
+}
+// ============ 存储中间件 ============
+/**
+ * 根据 URL 获取文件扩展名
+ */
+function getExtension(url, mime) {
+    // 优先使用 MIME 类型
+    if (mime) {
+        const mimeMap = {
+            'image/png': '.png',
+            'image/jpeg': '.jpg',
+            'image/gif': '.gif',
+            'image/webp': '.webp',
+            'video/mp4': '.mp4',
+            'video/webm': '.webm',
+            'audio/mp3': '.mp3',
+            'audio/mpeg': '.mp3',
+            'audio/wav': '.wav',
+        };
+        if (mimeMap[mime])
+            return mimeMap[mime];
+    }
+    // 从 URL 提取
+    try {
+        const pathname = new URL(url).pathname;
+        const ext = pathname.match(/\.[a-zA-Z0-9]+$/)?.[0];
+        if (ext)
+            return ext;
+    }
+    catch { }
+    return '.bin';
+}
+/**
+ * 生成唯一文件名
+ */
+function generateFilename(asset, index) {
+    const content = asset.url || asset.content || '';
+    const hash = createHash('md5').update(content).digest('hex').slice(0, 8);
+    const ext = asset.url ? getExtension(asset.url, asset.mime) : '.txt';
+    const timestamp = Date.now();
+    return `media-luna/output/${asset.kind}/${timestamp}-${index}-${hash}${ext}`;
+}
+/**
+ * 生成输入文件名
+ */
+function generateInputFilename(file, index) {
+    const hash = createHash('md5').update(Buffer.from(file.data)).digest('hex').slice(0, 8);
+    const ext = getExtensionFromMime(file.mime);
+    const timestamp = Date.now();
+    return `media-luna/input/${timestamp}-${index}-${hash}${ext}`;
+}
+/**
+ * 从 MIME 类型获取扩展名
+ */
+function getExtensionFromMime(mime) {
+    const mimeMap = {
+        'image/png': '.png',
+        'image/jpeg': '.jpg',
+        'image/gif': '.gif',
+        'image/webp': '.webp',
+        'video/mp4': '.mp4',
+        'video/webm': '.webm',
+        'audio/mp3': '.mp3',
+        'audio/mpeg': '.mp3',
+        'audio/wav': '.wav',
+        'audio/ogg': '.ogg',
+        'application/pdf': '.pdf',
+    };
+    return mimeMap[mime] || '.bin';
+}
+/**
+ * 下载文件
+ */
+async function downloadAsset(url) {
+    const resp = await fetch(url);
+    if (!resp.ok)
+        throw new Error(`下载失败: ${resp.status}`);
+    const arrayBuffer = await resp.arrayBuffer();
+    const mime = resp.headers.get('content-type') || 'application/octet-stream';
+    return { buffer: Buffer.from(arrayBuffer), mime };
+}
+/**
+ * 创建存储中间件
+ *
+ * 在 lifecycle-post-request 阶段将生成结果上传到外部存储
+ * 使用 AssetCacheService 统一处理缓存，享受数据库追踪和内容去重
+ */
+export function createStorageMiddleware(ctx, logger) {
+    return {
+        name: 'storage',
+        displayName: '存储缓存',
+        description: '将生成结果保存到本地或外部存储（本地缓存/S3/WebDAV）',
+        category: 'cache',
+        phase: 'lifecycle-post-request',
+        // 依赖通过 phase 自动处理，在 request 之后执行
+        configFields: storageConfigFields,
+        configGroup: 'storage',
+        async execute(mctx, next) {
+            const config = await mctx.getMiddlewareConfig('storage');
+            // 如果没有输出或未配置存储后端，跳过
+            if (!mctx.output || mctx.output.length === 0 || !config || config.backend === 'none') {
+                return next();
+            }
+            // 确保 AssetCacheService 使用最新配置
+            ctx.mediaLuna.assetCache.setConfig(config);
+            const uploadedAssets = [];
+            const uploadLogs = [];
+            for (let i = 0; i < mctx.output.length; i++) {
+                const asset = mctx.output[i];
+                // 文本类型资产使用 content，不需要上传
+                if (asset.kind === 'text' || !asset.url) {
+                    uploadedAssets.push(asset);
+                    continue;
+                }
+                try {
+                    const isBase64 = asset.url.startsWith('data:');
+                    // 使用 AssetCacheService 统一缓存（享受数据库追踪和内容去重）
+                    const cacheResult = await ctx.mediaLuna.assetCache.cacheAsset(asset.url);
+                    // 替换 URL
+                    uploadedAssets.push({
+                        ...asset,
+                        url: cacheResult.cachedUrl,
+                        meta: {
+                            ...asset.meta,
+                            ...(isBase64 ? {} : { originalUrl: asset.url }),
+                            storageKey: cacheResult.contentHash,
+                            storageBackend: cacheResult.backend,
+                            fromCache: cacheResult.fromCache
+                        }
+                    });
+                    uploadLogs.push({
+                        index: i,
+                        originalUrl: isBase64 ? '[base64 data]' : asset.url,
+                        newUrl: cacheResult.cachedUrl
+                    });
+                    logger.debug(`Cached asset ${i} to ${cacheResult.backend}: ${cacheResult.cachedUrl}${cacheResult.fromCache ? ' (from cache)' : ''}`);
+                }
+                catch (error) {
+                    // 上传失败，保留原始资产
+                    uploadedAssets.push(asset);
+                    const isBase64 = asset.url.startsWith('data:');
+                    uploadLogs.push({
+                        index: i,
+                        originalUrl: isBase64 ? '[base64 data]' : asset.url,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                    logger.warn(`Failed to cache asset ${i}:`, error);
+                }
+            }
+            // 更新输出
+            mctx.output = uploadedAssets;
+            mctx.setMiddlewareLog('storage', {
+                backend: config.backend,
+                total: mctx.output.length,
+                uploaded: uploadLogs.filter(l => l.newUrl).length,
+                failed: uploadLogs.filter(l => l.error).length,
+                logs: uploadLogs
+            });
+            return next();
+        }
+    };
+}
+/**
+ * 创建输入存储中间件
+ *
+ * 在 lifecycle-prepare 阶段将输入文件上传到外部存储
+ * 将 files 中的二进制数据替换为 URL，便于后续存储到任务记录
+ * 使用 AssetCacheService 统一处理缓存，享受数据库追踪和内容去重
+ */
+export function createStorageInputMiddleware(ctx, logger) {
+    return {
+        name: 'storage-input',
+        displayName: '输入文件存储',
+        description: '将输入文件保存到本地或外部存储（本地缓存/S3/WebDAV）',
+        category: 'cache',
+        phase: 'lifecycle-prepare',
+        configFields: storageConfigFields,
+        configGroup: 'storage',
+        async execute(mctx, next) {
+            const config = await mctx.getMiddlewareConfig('storage');
+            // 如果没有输入文件或未配置存储后端，跳过
+            if (!mctx.files || mctx.files.length === 0 || !config || config.backend === 'none') {
+                return next();
+            }
+            // 确保 AssetCacheService 使用最新配置
+            ctx.mediaLuna.assetCache.setConfig(config);
+            const uploadLogs = [];
+            const uploadedUrls = [];
+            for (let i = 0; i < mctx.files.length; i++) {
+                const file = mctx.files[i];
+                // 跳过空数据的文件
+                if (!file.data || file.data.byteLength === 0) {
+                    continue;
+                }
+                try {
+                    // 将二进制数据转换为 data URL
+                    const buffer = Buffer.from(file.data);
+                    const base64 = buffer.toString('base64');
+                    const dataUrl = `data:${file.mime};base64,${base64}`;
+                    // 使用 AssetCacheService 统一缓存
+                    const cacheResult = await ctx.mediaLuna.assetCache.cacheAsset(dataUrl);
+                    uploadedUrls.push(cacheResult.cachedUrl);
+                    uploadLogs.push({
+                        index: i,
+                        filename: file.filename,
+                        url: cacheResult.cachedUrl
+                    });
+                    logger.debug(`Cached input file ${i} to ${cacheResult.backend}: ${cacheResult.cachedUrl}${cacheResult.fromCache ? ' (from cache)' : ''}`);
+                }
+                catch (error) {
+                    uploadLogs.push({
+                        index: i,
+                        filename: file.filename,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                    logger.warn(`Failed to cache input file ${i}:`, error);
+                }
+            }
+            // 将上传的 URL 存储到 store 中，供 task-recorder 使用
+            if (uploadedUrls.length > 0) {
+                mctx.store.set('inputFileUrls', uploadedUrls);
+            }
+            mctx.setMiddlewareLog('storage-input', {
+                backend: config.backend,
+                total: mctx.files.length,
+                uploaded: uploadLogs.filter(l => l.url).length,
+                failed: uploadLogs.filter(l => l.error).length,
+                urls: uploadedUrls,
+                logs: uploadLogs
+            });
+            return next();
+        }
+    };
+}
+//# sourceMappingURL=storage.js.map