koishi-plugin-media-luna 0.0.1

package/lib/services/asset-cache.service.js

@@ -0,0 +1,882 @@
+// Asset Cache Service - 通用资源缓存服务
+// 使用数据库追踪缓存记录，支持多后端（local/S3/WebDAV）
+// 特性：
+// - 基于内容 hash 去重（相同内容只存储一次）
+// - 支持 base64 data URL 解析
+// - 支持普通 HTTP(S) URL 下载
+// - 支持配置公开访问的 baseUrl
+import { Logger } from 'koishi';
+import { createHash, createHmac } from 'crypto';
+import { createReadStream } from 'fs';
+import { promises as fs } from 'fs';
+import { join, dirname, basename, resolve } from 'path';
+/**
+ * 解析 base64 data URL
+ * 格式: data:[<mediatype>][;base64],<data>
+ */
+function parseDataUrl(dataUrl) {
+    const match = dataUrl.match(/^data:([^;,]+)?(?:;base64)?,(.*)$/);
+    if (!match)
+        return null;
+    const mimeType = match[1] || 'application/octet-stream';
+    const base64Data = match[2];
+    try {
+        const buffer = Buffer.from(base64Data, 'base64');
+        return { mimeType, buffer };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 检查是否是 data URL
+ */
+function isDataUrl(url) {
+    return url.startsWith('data:');
+}
+// ============ S3 上传辅助函数 ============
+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)}`;
+}
+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 };
+}
+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 };
+}
+// ============ WebDAV 上传辅助函数 ============
+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 };
+}
+// ============ 本地上传辅助函数 ============
+// 自动检测的 server baseUrl（从 Koishi server 获取）
+let autoDetectedBaseUrl = null;
+// 本地存储根目录（绝对路径）
+let localStorageRoot = null;
+// 本地存储路径（URL 路径）
+let localStoragePath = '/media-luna/assets';
+/**
+ * 初始化本地存储服务（仿照 Koishi assets-local 实现）
+ * - 使用 ctx.server 注册路由
+ * - 使用 file-type 流式检测 MIME
+ * - 使用 basename 防止路径遍历
+ */
+export function initAssetCacheLocalStorage(ctx, logger) {
+    const baseDir = ctx.baseDir || process.cwd();
+    localStorageRoot = resolve(baseDir, 'data/media-luna/assets');
+    // 获取 selfUrl
+    const server = ctx.get('server');
+    if (server) {
+        const selfUrl = server.config?.selfUrl;
+        if (selfUrl) {
+            autoDetectedBaseUrl = selfUrl.replace(/\/$/, '');
+        }
+    }
+    // 如果没有 selfUrl，监听 server/ready 事件获取
+    if (!autoDetectedBaseUrl) {
+        ctx.on('server/ready', () => {
+            const srv = ctx.get('server');
+            if (srv) {
+                const selfUrl = srv.config?.selfUrl;
+                if (selfUrl) {
+                    autoDetectedBaseUrl = selfUrl.replace(/\/$/, '');
+                }
+                else {
+                    const port = srv.config?.port || 5140;
+                    const host = srv.config?.host || 'localhost';
+                    autoDetectedBaseUrl = `http://${host === '0.0.0.0' ? 'localhost' : host}:${port}`;
+                }
+                logger.info(`Asset cache base URL: ${autoDetectedBaseUrl}`);
+            }
+        });
+    }
+    // 注册路由（仿照 assets-local）
+    if (server) {
+        // 获取统计信息
+        server.get(localStoragePath, async (reqCtx) => {
+            const stats = await getLocalStorageStats();
+            reqCtx.body = stats;
+        });
+        // 提供文件服务（仿照 assets-local: 使用流式读取 + file-type 自动检测）
+        server.get(localStoragePath + '/:name', async (reqCtx) => {
+            // 使用 basename 防止路径遍历（与 assets-local 一致）
+            const name = basename(reqCtx.params.name);
+            // 使用默认的存储根目录（在路由注册时已经确定）
+            const root = localStorageRoot;
+            const filename = resolve(root, name);
+            logger.debug(`Serving file: ${filename} (root: ${root}, name: ${name})`);
+            try {
+                // 先检查文件是否存在
+                await fs.access(filename);
+                // 动态导入 file-type（ESM 模块）
+                const fileType = await import('file-type');
+                // file-type 的 stream 函数可能在 default 上或直接导出
+                const streamFn = fileType.stream || fileType.default?.stream;
+                if (streamFn) {
+                    const stream = await streamFn(createReadStream(filename));
+                    reqCtx.type = stream.fileType?.mime || 'application/octet-stream';
+                    reqCtx.body = stream;
+                }
+                else {
+                    // 回退：直接读取文件，根据扩展名猜测 MIME
+                    const ext = name.split('.').pop()?.toLowerCase();
+                    reqCtx.type = getMimeFromExtension(ext) || 'application/octet-stream';
+                    reqCtx.body = createReadStream(filename);
+                }
+            }
+            catch (err) {
+                logger.warn(`File not found or error: ${filename}`, err);
+                reqCtx.status = 404;
+                reqCtx.body = 'File not found';
+            }
+        });
+        // 兼容旧路径 /media-luna/cache/:name
+        server.get('/media-luna/cache/:name', async (reqCtx) => {
+            const name = basename(reqCtx.params.name);
+            const root = localStorageRoot;
+            const filename = resolve(root, name);
+            try {
+                await fs.access(filename);
+                const fileType = await import('file-type');
+                const streamFn = fileType.stream || fileType.default?.stream;
+                if (streamFn) {
+                    const stream = await streamFn(createReadStream(filename));
+                    reqCtx.type = stream.fileType?.mime || 'application/octet-stream';
+                    reqCtx.body = stream;
+                }
+                else {
+                    const ext = name.split('.').pop()?.toLowerCase();
+                    reqCtx.type = getMimeFromExtension(ext) || 'application/octet-stream';
+                    reqCtx.body = createReadStream(filename);
+                }
+            }
+            catch {
+                reqCtx.status = 404;
+                reqCtx.body = 'File not found';
+            }
+        });
+        logger.info('Asset cache routes registered: /media-luna/assets/*, /media-luna/cache/*');
+    }
+}
+/**
+ * 获取本地存储统计信息（仿照 assets-local）
+ */
+async function getLocalStorageStats() {
+    if (!localStorageRoot) {
+        return { assetCount: 0, assetSize: 0 };
+    }
+    let assetCount = 0;
+    let assetSize = 0;
+    try {
+        const files = await fs.readdir(localStorageRoot);
+        assetCount = files.length;
+        await Promise.all(files.map(async (file) => {
+            try {
+                const fileStat = await fs.stat(resolve(localStorageRoot, file));
+                assetSize += fileStat.size;
+            }
+            catch { }
+        }));
+    }
+    catch { }
+    return { assetCount, assetSize };
+}
+function getLocalPublicUrl(config, relativePath) {
+    const publicPath = config.localPublicPath || '/media-luna/assets';
+    // 优先使用用户配置的 baseUrl，否则使用自动检测的
+    const baseUrl = config.localPublicBaseUrl || autoDetectedBaseUrl || '';
+    return `${baseUrl}${publicPath}/${relativePath}`;
+}
+async function uploadToLocal(buffer, filename, mime, config) {
+    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);
+    const publicUrl = getLocalPublicUrl(config, filename);
+    return {
+        url: publicUrl,
+        key: filename
+    };
+}
+// ============ Koishi Assets 上传辅助函数 ============
+/**
+ * 使用 Koishi 的 assets 服务上传资源
+ * 需要用户安装 assets-local、assets-s3 等 assets 插件
+ */
+async function uploadWithKoishiAssets(ctx, source, filename) {
+    const assets = ctx.get('assets');
+    if (!assets) {
+        throw new Error('Koishi assets service is not available. Please install an assets plugin (e.g. assets-local, assets-s3).');
+    }
+    // ctx.assets.upload(url, file) 会自动下载 URL 内容并存储
+    // 对于 data URL 也可以直接处理
+    const cachedUrl = await assets.upload(source, filename);
+    return {
+        url: cachedUrl,
+        key: filename
+    };
+}
+/**
+ * 检查 Koishi assets 服务是否可用
+ */
+function isKoishiAssetsAvailable(ctx) {
+    try {
+        const assets = ctx.get('assets');
+        return !!assets;
+    }
+    catch {
+        return false;
+    }
+}
+// ============ MIME 类型辅助函数 ============
+const extensionMimeMap = {
+    'jpg': 'image/jpeg',
+    'jpeg': 'image/jpeg',
+    'png': 'image/png',
+    'gif': 'image/gif',
+    'webp': 'image/webp',
+    'svg': 'image/svg+xml',
+    'mp3': 'audio/mpeg',
+    'wav': 'audio/wav',
+    'ogg': 'audio/ogg',
+    'mp4': 'video/mp4',
+    'webm': 'video/webm'
+};
+function getMimeFromExtension(ext) {
+    return extensionMimeMap[ext || ''] || 'application/octet-stream';
+}
+function getMimeFromUrl(url) {
+    const ext = url.split('.').pop()?.toLowerCase()?.split('?')[0];
+    return getMimeFromExtension(ext);
+}
+function getExtensionFromMime(mime) {
+    const mimeMap = {
+        'image/png': '.png',
+        'image/jpeg': '.jpg',
+        'image/gif': '.gif',
+        'image/webp': '.webp',
+        'image/svg+xml': '.svg',
+        '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';
+}
+// ============ Asset Cache Service ============
+export class AssetCacheService {
+    ctx;
+    logger;
+    config = null;
+    configGetter = null;
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.logger = new Logger('media-luna:asset-cache');
+    }
+    /**
+     * 设置配置获取函数（避免循环依赖）
+     */
+    setConfigGetter(getter) {
+        this.configGetter = getter;
+    }
+    /**
+     * 设置存储配置
+     */
+    setConfig(config) {
+        this.config = config;
+    }
+    /**
+     * 获取当前配置
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * 检查 Koishi assets 服务是否可用
+     */
+    isAssetsServiceAvailable() {
+        return isKoishiAssetsAvailable(this.ctx);
+    }
+    /**
+     * 从设置中加载存储配置（从 YAML 配置文件）
+     */
+    async loadConfigFromSettings() {
+        try {
+            // 使用配置获取函数（避免循环依赖）
+            if (this.configGetter) {
+                const mwConfig = this.configGetter();
+                if (mwConfig.config && mwConfig.config.backend && mwConfig.config.backend !== 'none') {
+                    this.config = mwConfig.config;
+                    return this.config;
+                }
+            }
+        }
+        catch (e) {
+            this.logger.warn('Failed to load storage config from settings:', e);
+        }
+        return null;
+    }
+    /**
+     * 计算内容的 SHA256 hash
+     */
+    hashContent(buffer) {
+        return createHash('sha256').update(buffer).digest('hex');
+    }
+    /**
+     * 计算源 URL 的 hash（用于记录来源，非去重）
+     */
+    hashSource(source) {
+        return createHash('sha256').update(source).digest('hex');
+    }
+    /**
+     * 根据源 URL hash 快速查找缓存（第一级查找）
+     */
+    async getCachedBySource(sourceUrl) {
+        const sourceHash = this.hashSource(sourceUrl);
+        const rows = await this.ctx.database.get('medialuna_asset_cache', { sourceHash });
+        if (rows.length > 0) {
+            // 更新最后访问时间
+            await this.ctx.database.set('medialuna_asset_cache', { id: rows[0].id }, {
+                lastAccessedAt: new Date()
+            });
+            return rows[0];
+        }
+        return null;
+    }
+    /**
+     * 根据内容 hash 检查是否已缓存（第二级查找，用于去重）
+     */
+    async getCachedByContent(contentHash) {
+        const rows = await this.ctx.database.get('medialuna_asset_cache', { contentHash });
+        if (rows.length > 0) {
+            // 更新最后访问时间
+            await this.ctx.database.set('medialuna_asset_cache', { id: rows[0].id }, {
+                lastAccessedAt: new Date()
+            });
+            return rows[0];
+        }
+        return null;
+    }
+    /**
+     * 获取资源内容（处理 URL 或 data URL）
+     */
+    async fetchContent(source) {
+        // 处理 base64 data URL
+        if (isDataUrl(source)) {
+            const parsed = parseDataUrl(source);
+            if (!parsed) {
+                throw new Error('Invalid data URL format');
+            }
+            return { buffer: parsed.buffer, mimeType: parsed.mimeType };
+        }
+        // 普通 HTTP(S) URL
+        this.logger.debug(`Downloading ${source.slice(0, 100)}...`);
+        const response = await fetch(source);
+        if (!response.ok) {
+            throw new Error(`Failed to download: ${response.status} ${response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        const contentType = response.headers.get('content-type') || getMimeFromUrl(source);
+        const mimeType = contentType.split(';')[0].trim();
+        return { buffer, mimeType };
+    }
+    /**
+     * 缓存资源（URL 或 data URL）
+     *
+     * 使用两级缓存查找策略：
+     * 1. 第一级：用 sourceUrl 的 hash 快速查找（大部分情况命中，避免下载）
+     * 2. 第二级：下载后用 contentHash 查找（处理不同 URL 相同内容的去重）
+     *
+     * @param source 原始 URL 或 base64 data URL
+     * @returns 缓存结果
+     */
+    async cacheAsset(source) {
+        // 检查配置
+        if (!this.config) {
+            await this.loadConfigFromSettings();
+        }
+        if (!this.config) {
+            throw new Error('Asset cache not configured. Please configure storage settings first.');
+        }
+        // 第一级查找：用源 URL 快速查找（避免下载）
+        // 对于 base64 不做这个优化，因为 base64 本身就包含内容
+        if (!isDataUrl(source)) {
+            const existingBySource = await this.getCachedBySource(source);
+            if (existingBySource) {
+                this.logger.debug(`Cache hit by source URL: ${source.slice(0, 50)}`);
+                return {
+                    cachedUrl: existingBySource.cachedUrl,
+                    fromCache: true,
+                    backend: existingBySource.backend,
+                    fileSize: existingBySource.fileSize,
+                    contentHash: existingBySource.contentHash
+                };
+            }
+        }
+        // 获取内容（下载或解析 base64）
+        const { buffer, mimeType } = await this.fetchContent(source);
+        // 计算内容 hash
+        const contentHash = this.hashContent(buffer);
+        // 第二级查找：根据内容 hash 检查是否已缓存（处理不同 URL 相同内容的情况）
+        const existingByContent = await this.getCachedByContent(contentHash);
+        if (existingByContent) {
+            this.logger.debug(`Cache hit by content hash: ${contentHash.slice(0, 12)}`);
+            // 如果是新的源 URL，添加一条记录指向同一个缓存文件
+            // 这样下次用这个 URL 访问时可以走第一级快速路径
+            if (!isDataUrl(source)) {
+                const sourceHash = this.hashSource(source);
+                try {
+                    await this.ctx.database.create('medialuna_asset_cache', {
+                        sourceUrl: source,
+                        sourceHash,
+                        contentHash,
+                        backend: existingByContent.backend,
+                        cachedUrl: existingByContent.cachedUrl,
+                        cachedKey: existingByContent.cachedKey,
+                        mimeType: existingByContent.mimeType,
+                        fileSize: existingByContent.fileSize,
+                        createdAt: new Date(),
+                        lastAccessedAt: new Date()
+                    });
+                }
+                catch {
+                    // 可能 sourceHash 已存在，忽略
+                }
+            }
+            return {
+                cachedUrl: existingByContent.cachedUrl,
+                fromCache: true,
+                backend: existingByContent.backend,
+                fileSize: existingByContent.fileSize,
+                contentHash
+            };
+        }
+        // 生成唯一文件名（使用内容 hash）
+        const ext = getExtensionFromMime(mimeType);
+        const filename = `${contentHash.slice(0, 16)}${ext}`;
+        // 上传到对应后端
+        let result;
+        switch (this.config.backend) {
+            case 'koishi':
+                // 使用 Koishi 的 assets 服务
+                // 将 buffer 转换为 data URL 传递给 assets 服务，避免重复下载
+                const dataUrl = `data:${mimeType};base64,${buffer.toString('base64')}`;
+                result = await uploadWithKoishiAssets(this.ctx, dataUrl, filename);
+                break;
+            case 'local':
+                result = await uploadToLocal(buffer, filename, mimeType, this.config);
+                break;
+            case 's3':
+                result = await uploadToS3(buffer, filename, mimeType, this.config);
+                break;
+            case 'webdav':
+                result = await uploadToWebDav(buffer, filename, mimeType, this.config);
+                break;
+            default:
+                throw new Error(`Unknown backend: ${this.config.backend}`);
+        }
+        // 计算源 hash
+        const sourceForRecord = isDataUrl(source)
+            ? `base64://${contentHash}`
+            : source;
+        const sourceHash = this.hashSource(sourceForRecord);
+        // 保存到数据库
+        const now = new Date();
+        await this.ctx.database.create('medialuna_asset_cache', {
+            sourceUrl: sourceForRecord,
+            sourceHash,
+            contentHash,
+            backend: this.config.backend,
+            cachedUrl: result.url,
+            cachedKey: result.key,
+            mimeType,
+            fileSize: buffer.length,
+            createdAt: now,
+            lastAccessedAt: now
+        });
+        this.logger.info(`Cached ${isDataUrl(source) ? '[base64 data]' : source.slice(0, 50)} -> ${result.url} (${this.config.backend})`);
+        return {
+            cachedUrl: result.url,
+            fromCache: false,
+            backend: this.config.backend,
+            fileSize: buffer.length,
+            contentHash
+        };
+    }
+    /**
+     * 批量缓存资源
+     */
+    async cacheAssets(sources) {
+        const results = new Map();
+        for (const source of sources) {
+            try {
+                const result = await this.cacheAsset(source);
+                results.set(source, result);
+            }
+            catch (e) {
+                this.logger.warn(`Failed to cache ${isDataUrl(source) ? '[base64]' : source.slice(0, 50)}:`, e);
+            }
+        }
+        return results;
+    }
+    /**
+     * 从 Buffer 缓存资源（用于上传场景）
+     */
+    async cacheBuffer(buffer, mimeType, sourceIdentifier) {
+        // 检查配置
+        if (!this.config) {
+            await this.loadConfigFromSettings();
+        }
+        if (!this.config) {
+            throw new Error('Asset cache not configured. Please configure storage settings first.');
+        }
+        // 计算内容 hash
+        const contentHash = this.hashContent(buffer);
+        // 根据内容 hash 检查是否已缓存
+        const existing = await this.getCachedByContent(contentHash);
+        if (existing) {
+            return {
+                cachedUrl: existing.cachedUrl,
+                fromCache: true,
+                backend: existing.backend,
+                fileSize: existing.fileSize,
+                contentHash
+            };
+        }
+        // 生成文件名
+        const ext = getExtensionFromMime(mimeType);
+        const filename = `${contentHash.slice(0, 16)}${ext}`;
+        // 上传
+        let result;
+        switch (this.config.backend) {
+            case 'koishi':
+                // 使用 Koishi 的 assets 服务
+                const dataUrl = `data:${mimeType};base64,${buffer.toString('base64')}`;
+                result = await uploadWithKoishiAssets(this.ctx, dataUrl, filename);
+                break;
+            case 'local':
+                result = await uploadToLocal(buffer, filename, mimeType, this.config);
+                break;
+            case 's3':
+                result = await uploadToS3(buffer, filename, mimeType, this.config);
+                break;
+            case 'webdav':
+                result = await uploadToWebDav(buffer, filename, mimeType, this.config);
+                break;
+            default:
+                throw new Error(`Unknown backend: ${this.config.backend}`);
+        }
+        // 生成源标识
+        const sourceUrl = sourceIdentifier || `buffer://${contentHash}`;
+        const sourceHash = this.hashSource(sourceUrl);
+        // 保存到数据库
+        const now = new Date();
+        await this.ctx.database.create('medialuna_asset_cache', {
+            sourceUrl,
+            sourceHash,
+            contentHash,
+            backend: this.config.backend,
+            cachedUrl: result.url,
+            cachedKey: result.key,
+            mimeType,
+            fileSize: buffer.length,
+            createdAt: now,
+            lastAccessedAt: now
+        });
+        return {
+            cachedUrl: result.url,
+            fromCache: false,
+            backend: this.config.backend,
+            fileSize: buffer.length,
+            contentHash
+        };
+    }
+    /**
+     * 获取缓存统计信息
+     */
+    async getStats() {
+        const allRecords = await this.ctx.database.get('medialuna_asset_cache', {});
+        const stats = {
+            totalFiles: allRecords.length,
+            totalSizeMB: 0,
+            byBackend: {},
+            oldestAccess: null,
+            newestAccess: null
+        };
+        for (const record of allRecords) {
+            stats.totalSizeMB += record.fileSize / (1024 * 1024);
+            // 按后端统计
+            if (!stats.byBackend[record.backend]) {
+                stats.byBackend[record.backend] = { count: 0, sizeMB: 0 };
+            }
+            stats.byBackend[record.backend].count++;
+            stats.byBackend[record.backend].sizeMB += record.fileSize / (1024 * 1024);
+            // 最老/最新访问时间
+            const accessTime = new Date(record.lastAccessedAt);
+            if (!stats.oldestAccess || accessTime < stats.oldestAccess) {
+                stats.oldestAccess = accessTime;
+            }
+            if (!stats.newestAccess || accessTime > stats.newestAccess) {
+                stats.newestAccess = accessTime;
+            }
+        }
+        return stats;
+    }
+    /**
+     * 清理过期缓存（LRU 策略）
+     * @param maxAgeDays 保留天数
+     */
+    async cleanupExpired(maxAgeDays = 30) {
+        const cutoff = new Date();
+        cutoff.setDate(cutoff.getDate() - maxAgeDays);
+        const expiredRecords = await this.ctx.database.get('medialuna_asset_cache', {
+            lastAccessedAt: { $lt: cutoff }
+        });
+        let deletedCount = 0;
+        for (const record of expiredRecords) {
+            try {
+                // 删除本地文件（如果是 local 后端）
+                if (record.backend === 'local' && record.cachedKey) {
+                    const cacheDir = this.config?.localCacheDir || 'data/media-luna/assets';
+                    const filePath = join(process.cwd(), cacheDir, record.cachedKey);
+                    try {
+                        await fs.unlink(filePath);
+                    }
+                    catch {
+                        // 文件可能已不存在
+                    }
+                }
+                // 从数据库删除记录
+                await this.ctx.database.remove('medialuna_asset_cache', { id: record.id });
+                deletedCount++;
+            }
+            catch (e) {
+                this.logger.warn(`Failed to delete cache record ${record.id}:`, e);
+            }
+        }
+        if (deletedCount > 0) {
+            this.logger.info(`Cleaned up ${deletedCount} expired cache entries`);
+        }
+        return deletedCount;
+    }
+    /**
+     * 根据内容 hash 删除缓存
+     */
+    async deleteCacheByContentHash(contentHash) {
+        const records = await this.ctx.database.get('medialuna_asset_cache', { contentHash });
+        if (records.length === 0)
+            return false;
+        for (const record of records) {
+            // 删除本地文件
+            if (record.backend === 'local' && record.cachedKey) {
+                const cacheDir = this.config?.localCacheDir || 'data/media-luna/assets';
+                const filePath = join(process.cwd(), cacheDir, record.cachedKey);
+                try {
+                    await fs.unlink(filePath);
+                }
+                catch {
+                    // 忽略
+                }
+            }
+            await this.ctx.database.remove('medialuna_asset_cache', { id: record.id });
+        }
+        return true;
+    }
+    /**
+     * 清空所有缓存
+     */
+    async clearAll() {
+        const allRecords = await this.ctx.database.get('medialuna_asset_cache', {});
+        // 删除本地文件
+        for (const record of allRecords) {
+            if (record.backend === 'local' && record.cachedKey) {
+                const cacheDir = this.config?.localCacheDir || 'data/media-luna/assets';
+                const filePath = join(process.cwd(), cacheDir, record.cachedKey);
+                try {
+                    await fs.unlink(filePath);
+                }
+                catch {
+                    // 忽略
+                }
+            }
+        }
+        // 清空表
+        await this.ctx.database.remove('medialuna_asset_cache', {});
+        this.logger.info(`Cleared ${allRecords.length} cache entries`);
+        return allRecords.length;
+    }
+}
+//# sourceMappingURL=asset-cache.service.js.map