ehbrowser 1.0.0

package/dist/services/detail-store.js

@@ -0,0 +1,208 @@
+/*
+ * 画廊详情的持久缓存。一个画廊一个文件，放在 <缓存目录>/gallery/ 下。
+ *
+ * 当上游更新，gid/token会更新，同时为了保证缓存秒开，因此将缓存落盘
+ *
+ * 字段：
+ *   detail    详情本体，详情页需要
+ *   usedAt    写入/最后使用时间
+ *   checkedAt 上次查更新的时间
+ *   newer     查到的更新版本
+ *
+ * 读取时更新 mtime，清理按 mtime 判龄，读过就算用过。
+ *
+ * newer 查到就长期留着，新版本不会自己消失。只有「查过、当时没有」才隔一天重查，
+ * 间隔在 gallery-service 里。
+ *
+ * 缓存目录用户可以自行删除。文件不存在、内容损坏、JSON 不合法等当作没有缓存处理，坏文件直接删除。
+ */
+import { mkdir, readdir, readFile, rm, stat, utimes } from "node:fs/promises";
+import { join } from "node:path";
+import { writeFileAtomic } from "../config/atomic.js";
+const SUBDIR = "gallery";
+const DAY_MS = 86_400_000;
+/** token 过滤一次非字母数字字符，避免拼出目录穿越的路径 */
+function fileOf(dir, gid, token) {
+    const safe = token.replace(/[^0-9a-zA-Z]/g, "");
+    return join(dir, `${gid}-${safe}.json`);
+}
+function isDetail(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const item = value;
+    return typeof item.gid === "number" && typeof item.title === "string";
+}
+function isRelation(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const item = value;
+    return typeof item.gid === "number" && typeof item.token === "string";
+}
+export function createDetailStore(options) {
+    const log = options.logger ?? (() => undefined);
+    const dir = join(options.cacheDir, SUBDIR);
+    async function ensure() {
+        await mkdir(dir, { recursive: true, mode: 0o700 });
+    }
+    /** 读取一条记录，文件损坏时删除并按没有缓存处理 */
+    async function read(file) {
+        let text;
+        try {
+            text = await readFile(file, "utf8");
+        }
+        catch {
+            return null;
+        }
+        try {
+            const raw = JSON.parse(text);
+            if (!isDetail(raw["detail"])) {
+                throw new Error("detail 字段不是详情");
+            }
+            return {
+                detail: raw["detail"],
+                usedAt: Number(raw["usedAt"]) || 0,
+                checkedAt: raw["checkedAt"] === null ? null : Number(raw["checkedAt"]) || null,
+                newer: isRelation(raw["newer"]) ? raw["newer"] : null,
+            };
+        }
+        catch (error) {
+            log("warn", `画廊缓存损坏，已丢弃：${file}（${String(error)}）`);
+            await rm(file, { force: true });
+            return null;
+        }
+    }
+    return {
+        async get(gid, token) {
+            const file = fileOf(dir, gid, token);
+            const stored = await read(file);
+            if (stored === null) {
+                return null;
+            }
+            // 更新 mtime，清理按 mtime 判龄，读过即视为用过
+            const now = new Date();
+            await utimes(file, now, now).catch(() => undefined);
+            return stored;
+        },
+        async put(gid, token, detail) {
+            await ensure();
+            const file = fileOf(dir, gid, token);
+            // 保留旧的更新检查结果，已查到的新版本不会消失
+            const previous = await read(file);
+            const envelope = {
+                detail,
+                usedAt: Math.floor(Date.now() / 1000),
+                checkedAt: previous?.checkedAt ?? null,
+                newer: previous?.newer ?? null,
+            };
+            await writeFileAtomic(file, `${JSON.stringify(envelope)}\n`, { mode: 0o600 });
+        },
+        async saveCheck(gid, token, newer) {
+            const file = fileOf(dir, gid, token);
+            const previous = await read(file);
+            if (previous === null) {
+                // 没有详情时不单独保存检查结果，下次进入该画廊会重新检查
+                return;
+            }
+            const envelope = {
+                detail: previous.detail,
+                usedAt: previous.usedAt,
+                checkedAt: Math.floor(Date.now() / 1000),
+                newer,
+            };
+            await writeFileAtomic(file, `${JSON.stringify(envelope)}\n`, { mode: 0o600 });
+        },
+        async prune(days) {
+            const cutoff = Date.now() - Math.max(0, days) * DAY_MS;
+            let removed = 0;
+            let bytes = 0;
+            let names;
+            try {
+                names = await readdir(dir);
+            }
+            catch {
+                return { removed, bytes };
+            }
+            for (const name of names) {
+                if (!name.endsWith(".json")) {
+                    continue;
+                }
+                const file = join(dir, name);
+                try {
+                    const info = await stat(file);
+                    if (info.mtimeMs >= cutoff) {
+                        continue;
+                    }
+                    await rm(file, { force: true });
+                    removed += 1;
+                    bytes += info.size;
+                }
+                catch {
+                    // 遍历途中文件被删除，跳过
+                }
+            }
+            if (removed > 0) {
+                log("info", `画廊缓存清理：删掉 ${removed} 条（超过 ${days} 天没用过）`);
+            }
+            return { removed, bytes };
+        },
+        async clear() {
+            let removed = 0;
+            let bytes = 0;
+            let names;
+            try {
+                names = await readdir(dir);
+            }
+            catch {
+                return { removed, bytes };
+            }
+            for (const name of names) {
+                if (!name.endsWith(".json")) {
+                    continue;
+                }
+                const file = join(dir, name);
+                try {
+                    const info = await stat(file);
+                    await rm(file, { force: true });
+                    removed += 1;
+                    bytes += info.size;
+                }
+                catch {
+                    // 同上
+                }
+            }
+            return { removed, bytes };
+        },
+        async stats() {
+            let entries = 0;
+            let bytes = 0;
+            let oldest = null;
+            let newest = null;
+            let names;
+            try {
+                names = await readdir(dir);
+            }
+            catch {
+                return { entries, bytes, oldestUsedAt: null, newestUsedAt: null };
+            }
+            for (const name of names) {
+                if (!name.endsWith(".json")) {
+                    continue;
+                }
+                try {
+                    const info = await stat(join(dir, name));
+                    entries += 1;
+                    bytes += info.size;
+                    const at = Math.floor(info.mtimeMs / 1000);
+                    oldest = oldest === null ? at : Math.min(oldest, at);
+                    newest = newest === null ? at : Math.max(newest, at);
+                }
+                catch {
+                    // 同上
+                }
+            }
+            return { entries, bytes, oldestUsedAt: oldest, newestUsedAt: newest };
+        },
+    };
+}

package/dist/services/download-file.js

@@ -0,0 +1,127 @@
+/*
+ * 单文件下载。流式写入，边写边上报进度，支持中断，网络层失败可重试。
+ * 传输层用 undici 的 fetch：Node 内置 fetch 使用另一份 undici，无法挂载本项目配置的代理。
+ */
+import { createWriteStream } from "node:fs";
+import { mkdir, rename, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { fetch as undiciFetch } from "undici";
+/** 重试之间的间隔，按次数递增 */
+const RETRY_DELAY_MS = 1500;
+/** HTTP 层面的失败（4xx/5xx）：重试会得到同样的结果，因此不重试 */
+class DownloadHttpError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DownloadHttpError";
+    }
+}
+/**
+ * 下载到 targetPath，先写 .part 再改名，避免半截文件被当成完整文件
+ * 传入 attempts 后会在「连接失败、传输中断」这类失败上重试；HTTP 状态码不对时不重试
+ */
+export async function downloadFile(options) {
+    const attempts = Math.max(1, options.attempts ?? 1);
+    let lastError = new Error("下载失败");
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+        try {
+            return await downloadOnce(options);
+        }
+        catch (error) {
+            // 用户取消时不再重试；HTTP 错误重试同样没有意义
+            if (options.signal?.aborted === true || error instanceof DownloadHttpError) {
+                throw error;
+            }
+            lastError = error;
+            if (attempt < attempts) {
+                await delay(RETRY_DELAY_MS * attempt, options.signal);
+            }
+        }
+    }
+    throw lastError;
+}
+async function downloadOnce(options) {
+    await mkdir(dirname(options.targetPath), { recursive: true });
+    const partPath = `${options.targetPath}.part`;
+    // 超时与调用方的取消信号需同时生效：只传一个会使另一个失效（没有整体超时时请求会一直挂起）
+    const timeout = AbortSignal.timeout(options.timeoutMs ?? 10 * 60 * 1000);
+    const signal = options.signal === undefined ? timeout : AbortSignal.any([options.signal, timeout]);
+    let response;
+    try {
+        response = await undiciFetch(options.url, {
+            headers: options.headers,
+            signal,
+            dispatcher: options.dispatcher,
+        });
+    }
+    catch (error) {
+        // 取消与超时分开处理：原因只挂在 cause 上，不再拼进 message，
+        // 外层 describeError 会把 cause 链拼成一句，拼两次会重复
+        if (options.signal?.aborted === true) {
+            // 取消时不必带上底层的 "This operation was aborted"，该内容对用户没有信息量
+            throw new Error("下载已取消");
+        }
+        if (signal.reason instanceof Error && signal.reason.name === "TimeoutError") {
+            throw new Error("请求超时", { cause: error });
+        }
+        throw new Error("请求失败", { cause: error });
+    }
+    if (!response.ok) {
+        throw new DownloadHttpError(`下载失败：HTTP ${response.status}`);
+    }
+    if (response.body === null) {
+        throw new DownloadHttpError("下载失败：响应没有内容");
+    }
+    const totalHeader = response.headers.get("content-length");
+    const bytesTotal = totalHeader === null ? null : Number(totalHeader);
+    let bytesDone = 0;
+    const interval = options.progressIntervalMs ?? 500;
+    let lastReport = 0;
+    const source = Readable.fromWeb(response.body);
+    source.on("data", (chunk) => {
+        bytesDone += chunk.length;
+        const now = Date.now();
+        if (options.onProgress !== undefined && now - lastReport >= interval) {
+            lastReport = now;
+            options.onProgress({ bytesDone, bytesTotal });
+        }
+    });
+    try {
+        await pipeline(source, createWriteStream(partPath));
+    }
+    catch (error) {
+        await rm(partPath, { force: true });
+        if (options.signal?.aborted === true) {
+            // 取消时不必带上底层的 "This operation was aborted"，该内容对用户没有信息量
+            throw new Error("下载已取消");
+        }
+        throw new Error("写入失败", { cause: error });
+    }
+    await rm(options.targetPath, { force: true });
+    await rename(partPath, options.targetPath);
+    options.onProgress?.({ bytesDone, bytesTotal });
+    return { bytes: bytesDone, targetPath: options.targetPath };
+}
+/** 重试前的等待。等待期间被取消时直接抛出，不再继续 */
+function delay(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted === true) {
+            reject(new Error("下载已取消"));
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        function onAbort() {
+            clearTimeout(timer);
+            reject(new Error("下载已取消"));
+        }
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+/** 目录为空时直接用文件名，否则拼成相对路径 */
+export function joinIfRelative(directory, name) {
+    return directory === "" ? name : join(directory, name);
+}