ehbrowser 1.0.0

package/dist/services/search-cache.js

@@ -0,0 +1,78 @@
+/*
+ * 搜索结果缓存。存的是「最后一次检索的条件 + 结果」，界面重进搜索页时可以据此直接铺出列表。
+ * 只存在于本次运行期内：文件落在缓存目录的 temp 下，启动时先删除，之后由预热检索重新写入。
+ * 读取以内存中的副本为准，文件只是本次的落盘副本（便于排查，也让同一进程内的语义清楚）。
+ */
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+import { ensureDir, isNotFound, readTextIfExists, writeFileAtomic } from "../config/atomic.js";
+/** 缓存目录下的临时子目录，内容可随时删除 */
+export const TEMP_SUBDIR = "temp";
+const CACHE_FILENAME = "search.json";
+function isCache(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const entry = value;
+    return (typeof entry.savedAt === "number" &&
+        typeof entry.query === "object" &&
+        entry.query !== null &&
+        typeof entry.result === "object" &&
+        entry.result !== null &&
+        Array.isArray(entry.result.items));
+}
+export function createSearchCache(cacheDir) {
+    const file = join(cacheDir, TEMP_SUBDIR, CACHE_FILENAME);
+    let current = null;
+    /** 在途的落盘，按顺序串起来，避免两次写入互相覆盖 */
+    let writing = Promise.resolve();
+    async function readFromDisk() {
+        const text = await readTextIfExists(file);
+        if (text === null) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(text);
+            return isCache(parsed) ? parsed : null;
+        }
+        catch {
+            // 坏文件按没有缓存处理，下一次检索会覆盖它
+            return null;
+        }
+    }
+    return {
+        file,
+        async read() {
+            if (current !== null) {
+                return current;
+            }
+            // 内存中没有就读盘。文件是这份缓存的本体，进程外写入的内容也一并接受
+            current = await readFromDisk();
+            return current;
+        },
+        save(entry) {
+            current = entry;
+            writing = writing
+                .then(async () => {
+                await ensureDir(join(cacheDir, TEMP_SUBDIR));
+                await writeFileAtomic(file, `${JSON.stringify(entry)}\n`, { mode: 0o600 });
+            })
+                .catch(() => {
+                // 缓存写入失败不影响检索本身，只是下次需要重新获取
+            });
+        },
+        async discard() {
+            // 先等在途的落盘结束，避免删掉刚写入的文件
+            await writing;
+            current = null;
+            await rm(file, { force: true }).catch((error) => {
+                if (!isNotFound(error)) {
+                    throw error;
+                }
+            });
+        },
+        async flush() {
+            await writing;
+        },
+    };
+}

package/dist/services/storage-service.js

@@ -0,0 +1,27 @@
+/*
+ * 储存空间。统计本地画廊与画廊缓存的占用，并按时间清理缓存。
+ * 只清理详情持久缓存（detail-store），本地画廊的文件不受影响。
+ */
+export function createStorageService(options) {
+    async function stats() {
+        const [galleries, cache] = await Promise.all([
+            options.library.list(),
+            options.store.stats(),
+        ]);
+        return {
+            libraryBytes: galleries.reduce((sum, item) => sum + item.sizeBytes, 0),
+            libraryGalleries: galleries.length,
+            cacheBytes: cache.bytes,
+            cacheEntries: cache.entries,
+            cacheOldestAt: cache.oldestUsedAt,
+            cacheNewestAt: cache.newestUsedAt,
+        };
+    }
+    return {
+        stats,
+        async cleanup(days) {
+            const removed = await options.store.prune(days);
+            return { removed: removed.removed, bytes: removed.bytes, stats: await stats() };
+        },
+    };
+}

package/dist/services/translate-service.js

@@ -0,0 +1,208 @@
+/*
+ * 标签翻译词库。
+ * 数据来自上游项目 EhTagTranslation/Database：该项目每周把整份标签翻译（含简介）打成发布包，
+ * 这里按需下载其中最小的一份 db.text.json.gz，剥掉简介只留「原文 -> 中文名」，再存到缓存目录。
+ * 数据本体是 CC BY-NC-SA 3.0，不随程序分发，装不装、什么时候删都由用户决定。
+ * 没装词库时界面回落到内置的常用翻译表，功能不受影响。
+ */
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { gunzipSync } from "node:zlib";
+import { fetch as undiciFetch } from "undici";
+import { getDispatcher } from "../eh/index.js";
+import { describeError } from "../platform/errors.js";
+/** 发布包的固定地址。GitHub 的 latest 会 302 到当前版本的具体资源。 */
+const SOURCE_URL = "https://github.com/EhTagTranslation/Database/releases/latest/download/db.text.json.gz";
+/** 界面上标注的出处 */
+const SOURCE_LABEL = "EhTagTranslation/Database";
+const DOWNLOAD_TIMEOUT_MS = 120000;
+function tagsFile(cacheDir) {
+    return join(cacheDir, "translate", "tags.json");
+}
+/** 剥掉简介，只留命名空间名与标签名。 */
+function parseDatabase(text) {
+    const document = JSON.parse(text);
+    const namespaces = {};
+    for (const item of document.data ?? []) {
+        const name = typeof item.namespace === "string" ? item.namespace : "";
+        if (name === "") {
+            continue;
+        }
+        const label = typeof item.frontMatters?.name === "string" ? item.frontMatters.name : name;
+        const tags = {};
+        for (const [raw, entry] of Object.entries(item.data ?? {})) {
+            if (typeof entry.name === "string" && entry.name !== "") {
+                tags[raw.toLowerCase()] = entry.name;
+            }
+        }
+        namespaces[name] = { label, tags };
+    }
+    return {
+        version: versionOf(document.version),
+        namespaces,
+    };
+}
+/** 发布包自报的版本号，未必是字符串（可能是数字）。认不出来就给「未知」。 */
+function versionOf(raw) {
+    if (typeof raw === "string" && raw !== "") {
+        return raw;
+    }
+    return typeof raw === "number" ? String(raw) : "未知";
+}
+/** 发布包的版本号：跟随重定向后的地址里带着 tag，如 .../download/v7.28221.1/db.text.json.gz */
+function versionFromUrl(url) {
+    const matched = /\/download\/v?([^/]+)\//.exec(url);
+    return matched?.[1] ?? null;
+}
+function countTags(namespaces) {
+    let total = 0;
+    for (const item of Object.values(namespaces)) {
+        total += Object.keys(item.tags).length;
+    }
+    return total;
+}
+/** 下载发布包：整份文件与跳转后的地址（地址里带发布号）。 */
+async function downloadPackage() {
+    // 走用户配置的代理。GitHub 在国内大多要代理才连得上。
+    const dispatcher = getDispatcher() ?? undefined;
+    const signal = AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS);
+    // 先只看一跳：latest 会 302 到带版本号的地址，版本号就从那里取。
+    const head = await undiciFetch(SOURCE_URL, { redirect: "manual", signal, dispatcher });
+    const location = head.headers.get("location");
+    await head.body?.cancel();
+    if (head.status >= 400) {
+        throw new Error(`下载失败：HTTP ${head.status}`);
+    }
+    const response = await undiciFetch(location ?? SOURCE_URL, {
+        redirect: "follow",
+        signal,
+        dispatcher,
+    });
+    if (!response.ok) {
+        throw new Error(`下载失败：HTTP ${response.status}`);
+    }
+    return { location, packed: Buffer.from(await response.arrayBuffer()) };
+}
+export function createTranslateService(options) {
+    const log = options.logger ?? (() => undefined);
+    const file = tagsFile(options.cacheDir);
+    /** 落盘的那一份。首次读取后常驻内存，更新与删除时替换。 */
+    let stored = null;
+    let loaded = false;
+    let updating = false;
+    let error = null;
+    /** 首次访问时从磁盘读一次。文件损坏按没装处理，不影响启动。 */
+    async function ensureLoaded() {
+        if (loaded) {
+            return;
+        }
+        loaded = true;
+        try {
+            const text = await readFile(file, "utf8");
+            const parsed = JSON.parse(text);
+            if (typeof parsed.version === "string" && parsed.namespaces !== undefined) {
+                stored = parsed;
+            }
+        }
+        catch (caught) {
+            const code = caught.code;
+            if (code !== "ENOENT") {
+                error = `词库读取失败：${describeError(caught)}`;
+                log("warn", error);
+            }
+        }
+    }
+    /** 代理偶尔会在 TLS 握手阶段断开，重试一次。两次都失败才算失败。 */
+    async function download() {
+        let last = new Error("下载失败");
+        for (let attempt = 1; attempt <= 2; attempt += 1) {
+            try {
+                return await downloadPackage();
+            }
+            catch (caught) {
+                last = caught;
+                log("warn", `词库下载失败（第 ${attempt} 次）：${describeError(caught)}`);
+            }
+        }
+        throw last instanceof Error ? last : new Error(String(last));
+    }
+    function status() {
+        const namespaces = stored?.namespaces ?? {};
+        return {
+            installed: stored !== null,
+            version: stored?.version ?? null,
+            updatedAt: stored?.updatedAt ?? null,
+            source: SOURCE_URL,
+            tagCount: stored === null ? 0 : countTags(namespaces),
+            namespaceCount: Object.keys(namespaces).length,
+            updating,
+            error,
+        };
+    }
+    return {
+        async status() {
+            await ensureLoaded();
+            return status();
+        },
+        async database() {
+            await ensureLoaded();
+            if (stored === null) {
+                return null;
+            }
+            return {
+                version: stored.version,
+                updatedAt: stored.updatedAt,
+                source: SOURCE_LABEL,
+                namespaces: stored.namespaces,
+            };
+        },
+        async update() {
+            await ensureLoaded();
+            if (updating) {
+                return status();
+            }
+            updating = true;
+            error = null;
+            try {
+                const { location, packed } = await download();
+                const parsed = parseDatabase(gunzipSync(packed).toString("utf8"));
+                const next = {
+                    // 发布包里的 version 只是数据格式版本（数字），发布号在地址里。
+                    version: (location === null ? null : versionFromUrl(location)) ?? parsed.version,
+                    updatedAt: Math.floor(Date.now() / 1000),
+                    source: SOURCE_LABEL,
+                    namespaces: parsed.namespaces,
+                };
+                await mkdir(join(options.cacheDir, "translate"), { recursive: true });
+                // 先写临时文件再改名：中途失败不会留下半份词库。
+                const temporary = `${file}.tmp`;
+                await writeFile(temporary, JSON.stringify(next), "utf8");
+                await rename(temporary, file);
+                stored = next;
+                loaded = true;
+                log("info", `词库已更新：${next.version}，${Object.keys(next.namespaces).length} 个命名空间、${countTags(next.namespaces)} 条标签`);
+            }
+            catch (caught) {
+                error = describeError(caught);
+                log("warn", `词库更新失败：${error}`);
+            }
+            finally {
+                updating = false;
+            }
+            return status();
+        },
+        async remove() {
+            await ensureLoaded();
+            try {
+                await rm(file, { force: true });
+            }
+            catch (caught) {
+                error = describeError(caught);
+            }
+            stored = null;
+            loaded = true;
+            error = null;
+            return status();
+        },
+    };
+}

package/dist/services/update-service.js

@@ -0,0 +1,268 @@
+/*
+ * 本地画廊的更新检查。
+ *
+ * 逐个向上游查询该画廊是否存在更新版本：取详情中的 current 关系，再取新版本的发布时间。
+ * 上游限流较严，默认 5 秒一次请求，因此按队列串行查询，查到一条推送一条，
+ * 界面边查边显示，不需要等整批查完。
+ *
+ * 结果只留在内存中，全局共享一份，应用重启即清空。
+ */
+/** 本地画廊的身份：与本地库、播放列表保持一致 */
+function keyOf(target) {
+    return target.key;
+}
+/** 本地画廊 -> 检查目标 */
+function targetOf(gallery) {
+    return {
+        key: `${gallery.gid}-${gallery.resolution}`,
+        gid: gallery.gid,
+        token: gallery.token,
+        title: gallery.summary?.title ?? gallery.title,
+        thumbUrl: gallery.summary?.thumbUrl ?? "",
+        postedAt: gallery.summary?.postedAt ?? gallery.downloadedAt,
+        pageCount: gallery.pageCount,
+    };
+}
+export function createUpdateService(library, gallery, options = {}) {
+    const log = options.logger ?? (() => undefined);
+    /** key -> 结果。Map 的插入顺序就是检查顺序 */
+    const entries = new Map();
+    const listeners = new Set();
+    const stateListeners = new Set();
+    /** 排队未查的 key。值中记录检查目标与来源，收藏与本地画廊共用一条队列 */
+    let queue = [];
+    /**
+     * 尚未查完的条数，含正在查的那一条。
+     * 该值不能直接用 queue.length：正在查的那条已从队列中取出，
+     * 界面上的「还剩 N」会从 N-1 起算，看起来少一条。
+     */
+    let remaining = 0;
+    /**
+     * 被「删除更新任务」移除的 key。
+     * 正在查的那条同样会被移除：其查完的结果需要丢弃，否则数秒后又会重新出现在列表中。
+     */
+    const forgotten = new Set();
+    const pending = new Map();
+    /**
+     * 轮次号。reset 时加一：上一轮在途的请求作废，查完也不再写入结果，
+     * 否则「清空后只查选中项」会被上一轮迟到的结果污染。
+     */
+    let generation = 0;
+    /** 当前运行中的轮次，null 表示没有活动循环 */
+    let activeRun = null;
+    /** 每轮一个取消信号：reset 时中断在途的上游请求 */
+    let controller = new AbortController();
+    function state() {
+        return {
+            // 有排队或正在请求的条目都算「检查中」，界面上的进度才不会频繁闪烁
+            checking: activeRun !== null || queue.length > 0,
+            entries: [...entries.values()],
+            pending: remaining,
+        };
+    }
+    function publishState() {
+        const next = state();
+        for (const listener of stateListeners) {
+            try {
+                listener(next);
+            }
+            catch {
+                // 单个订阅者异常不影响其余订阅者
+            }
+        }
+    }
+    function publish(entry) {
+        remaining = Math.max(0, remaining - 1);
+        // 已被移除的条目：结果丢弃，进度仍然推进
+        if (!forgotten.has(entry.key)) {
+            entries.set(entry.key, entry);
+            for (const listener of listeners) {
+                listener(entry);
+            }
+        }
+        // 这一条查完后剩余条数减少，进度随之更新一次
+        publishState();
+    }
+    async function checkOne(target, source, signal) {
+        const base = {
+            key: target.key,
+            gid: target.gid,
+            source,
+            resolution: target.resolution ?? "",
+            title: target.title,
+            thumbUrl: target.thumbUrl,
+            localPostedAt: target.postedAt,
+            localPageCount: target.pageCount,
+            checkedAt: Math.floor(Date.now() / 1000),
+        };
+        try {
+            // 更新检查必须请求上游接口，不能使用详情缓存，否则刚发布的新版本会被判为「已是最新」
+            const detail = await gallery.detail(target.gid, target.token, { fresh: true });
+            if (signal.aborted) {
+                throw new Error("已取消");
+            }
+            /*
+             * 上游刚取回的详情比本地快照准确，本地这一版的日期与封面以它为准。
+             * 收藏条目本地只记录加入收藏的时间，不作修正时「当前」一栏会显示成加入时间。
+             * 页数仍用本地记录值：本地下载可能比上游少几页，该差值需要展示给用户。
+             */
+            const held = {
+                ...base,
+                title: detail.title === "" ? base.title : detail.title,
+                thumbUrl: detail.thumbUrl === "" ? base.thumbUrl : detail.thumbUrl,
+                localPostedAt: detail.postedAt > 0 ? detail.postedAt : base.localPostedAt,
+            };
+            // current 指向自身时同样算「已是最新」
+            if (detail.current === null || detail.current.gid === target.gid) {
+                return { ...held, latest: null, error: null };
+            }
+            // 存在更新版本：一并取回其发布时间与页数，界面上需要显示「当前 -> 更新至」
+            const newest = await gallery.summaryOf(detail.current.gid, detail.current.token, signal);
+            return {
+                ...held,
+                latest: {
+                    gid: detail.current.gid,
+                    token: detail.current.token,
+                    postedAt: newest.postedAt,
+                    pageCount: newest.pageCount,
+                },
+                error: null,
+            };
+        }
+        catch (error) {
+            return {
+                ...base,
+                latest: null,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * 逐条检查。同一时刻只运行一个循环，每一轮都会检查轮次号：
+     * 被 reset 顶替后立即退出，已取回的结果也一并丢弃。
+     */
+    async function run(gen) {
+        if (activeRun !== null) {
+            // 已有循环在运行：它会自行发现轮次变化，此处不再新建
+            return;
+        }
+        activeRun = gen;
+        const signal = controller.signal;
+        try {
+            for (;;) {
+                if (gen !== generation) {
+                    return;
+                }
+                const key = queue.shift();
+                if (key === undefined) {
+                    break;
+                }
+                const target = pending.get(key);
+                if (target === undefined) {
+                    // 该条目在排队期间被删除，不再保留在待查队列中
+                    continue;
+                }
+                const entry = await checkOne(target.target, target.source, signal);
+                if (gen !== generation) {
+                    // 查完时已换代：该条属于上一轮，不写入结果
+                    return;
+                }
+                publish(entry);
+                log("info", entry.error === null
+                    ? `更新检查：#${target.target.gid} ${entry.latest === null ? "已是最新" : "有更新"}`
+                    : `更新检查失败：#${target.target.gid} ${entry.error}`);
+            }
+        }
+        finally {
+            if (activeRun === gen) {
+                activeRun = null;
+            }
+            // 换代期间排入的新队列需要继续执行
+            if (generation !== gen) {
+                void run(generation);
+            }
+            else {
+                // 整轮结束：checked 归零，界面据此把按钮恢复成「检查更新*」
+                publishState();
+            }
+        }
+    }
+    return {
+        state,
+        async check(input) {
+            const reset = input.reset === true;
+            if (reset) {
+                // 作废上一轮：清空结果与队列，并中断在途请求
+                generation += 1;
+                queue = [];
+                remaining = 0;
+                forgotten.clear();
+                entries.clear();
+                controller.abort();
+                controller = new AbortController();
+            }
+            const gen = generation;
+            // 检查目标：显式传入时使用传入的条目（收藏页传收藏条目），否则检查全部本地画廊
+            const targets = input.targets === undefined || input.targets.length === 0
+                ? (await library.list()).map((item) => ({
+                    target: targetOf(item),
+                    source: "library",
+                }))
+                : input.targets.map((target) => ({
+                    target,
+                    source: "favorites",
+                }));
+            const wanted = input.keys === undefined || input.keys.length === 0
+                ? targets
+                : targets.filter((item) => input.keys?.includes(item.target.key) === true);
+            const queued = new Set(queue);
+            for (const item of wanted) {
+                const key = item.target.key;
+                // 已在队列中的不重复排队；已查过的仅在本次要求重置时重新排队
+                if (queued.has(key) || (entries.has(key) && !reset)) {
+                    continue;
+                }
+                queued.add(key);
+                pending.set(key, item);
+                queue.push(key);
+                // 显式重查时将其从已删除集合中移除，否则结果会一直被丢弃
+                forgotten.delete(key);
+                remaining += 1;
+            }
+            void run(gen);
+            const next = state();
+            // 排完队先发布一次状态，界面立刻显示「还剩 N」
+            publishState();
+            return next;
+        },
+        onChange(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        onState(listener) {
+            stateListeners.add(listener);
+            return () => {
+                stateListeners.delete(listener);
+            };
+        },
+        forget(keys) {
+            const wanted = new Set(keys);
+            for (const key of wanted) {
+                entries.delete(key);
+                pending.delete(key);
+                forgotten.add(key);
+            }
+            // 撤除仍在排队的条目时，计数同步减少，否则「还剩 N」会停在该值上
+            const queuedRemoved = queue.filter((key) => wanted.has(key)).length;
+            if (queuedRemoved > 0) {
+                queue = queue.filter((key) => !wanted.has(key));
+                remaining = Math.max(0, remaining - queuedRemoved);
+            }
+            log("info", `已从更新列表移除 ${wanted.size} 条`);
+            publishState();
+            return state();
+        },
+    };
+}

package/dist/services/upstream-service.js

@@ -0,0 +1,64 @@
+/*
+ * 上游服务：把配置里的网络设置接到传输层，并用当前账号的 Cookie 组装调用参数
+ * 代理（含认证）与请求间隔在配置变更时即时生效
+ * SOCKS5 不受支持，配置为该协议时按直连处理并记录警告
+ */
+import { activeAccount } from "../config/index.js";
+import { clearProxyAgent, gdata, gtoken, setProxyAgent, setRequestInterval, showpage, } from "../eh/index.js";
+import { describeError } from "../platform/errors.js";
+export function createUpstreamService(ctx, service, options = {}) {
+    const log = options.logger ?? (() => undefined);
+    function applyNetwork() {
+        const { proxy, requestIntervalMs, maxSequentialRequests } = service.snapshot().setting.network;
+        if (!proxy.enabled) {
+            clearProxyAgent();
+            log("info", "代理未启用，按直连处理");
+        }
+        else {
+            const credentials = ctx.auth.get().proxyAuth;
+            try {
+                setProxyAgent(`${proxy.protocol}://${proxy.host}:${proxy.port}`, credentials.username === "" ? undefined : credentials.username, credentials.password);
+                log("info", `代理已启用：${proxy.protocol}://${proxy.host}:${proxy.port}`);
+            }
+            catch (error) {
+                clearProxyAgent();
+                log("warn", `代理设置失败，按直连处理：${describeError(error)}`);
+            }
+        }
+        setRequestInterval(requestIntervalMs, maxSequentialRequests);
+    }
+    function callOptions() {
+        const account = activeAccount(ctx.auth.get());
+        if (account === null) {
+            return null;
+        }
+        const cookies = {
+            ipb_member_id: account.cookies.ipbMemberId,
+            ipb_pass_hash: account.cookies.ipbPassHash,
+            igneous: account.cookies.igneous,
+        };
+        if (account.cookies.ipbSessionId !== undefined) {
+            cookies["ipb_session_id"] = account.cookies.ipbSessionId;
+        }
+        return { site: account.site, cookies };
+    }
+    /** 未登录时不追加 Cookie，公开接口仍可用 */
+    function withAuth(extra = {}) {
+        return { ...(callOptions() ?? {}), ...extra };
+    }
+    applyNetwork();
+    service.onChange(() => {
+        applyNetwork();
+    });
+    ctx.auth.onChange(() => {
+        log("info", "账号变更，后续请求使用新凭据");
+    });
+    return {
+        applyNetwork,
+        callOptions,
+        hasAccount: () => activeAccount(ctx.auth.get()) !== null,
+        gdata: (pairs, extra) => gdata(pairs, withAuth(extra)),
+        gtoken: (pages) => gtoken(pages, withAuth()),
+        showpage: (input) => showpage(input, withAuth()),
+    };
+}