ehbrowser 1.0.0

package/dist/config/migrations.js

@@ -0,0 +1,100 @@
+/*
+ * 版本迁移。约定：迁移前备份；文件版本高于程序版本时只读；migrate 为纯函数。
+ * 只补「这一版新增且无法从旧值推出」的字段，缺失字段另有默认值层兜底。
+ */
+import { AUTH_SETTING_VERSION, USER_SETTING_VERSION } from "./schema.js";
+/** 结构变更示例：
+ *  { from: 1, to: 2, migrate: (data) => ({ ...data, schemaVersion: 2, 新字段: 默认值 }) }
+ */
+export const USER_SETTING_MIGRATIONS = [
+    {
+        // v2 为播放器补上缓存上限、并发加载与自动播放设置，另加翻译开关
+        from: 1,
+        to: 2,
+        migrate: (data) => {
+            const viewer = (data["viewer"] ?? {});
+            return {
+                ...data,
+                schemaVersion: 2,
+                viewer: {
+                    ...viewer,
+                    ...(viewer["maxCacheMb"] === undefined ? { maxCacheMb: 512 } : {}),
+                    ...(viewer["maxConcurrentLoads"] === undefined
+                        ? { maxConcurrentLoads: 3 }
+                        : {}),
+                    ...(viewer["autoplay"] === undefined
+                        ? { autoplay: { enabled: false, intervalSeconds: 5, loop: false } }
+                        : {}),
+                },
+                ...(data["translate"] === undefined ? { translate: { tags: false } } : {}),
+            };
+        },
+    },
+    {
+        // v3 增加紧急避险：默认开启提示，跳转地址为空白页
+        from: 2,
+        to: 3,
+        migrate: (data) => ({
+            ...data,
+            schemaVersion: 3,
+            ...(data["safety"] === undefined
+                ? { safety: { hintEnabled: true, url: "about:blank" } }
+                : {}),
+        }),
+    },
+    {
+        // v4 增加日志：默认写入文件，目录留空时使用默认的 ~/ehbrowser/logs
+        from: 3,
+        to: 4,
+        migrate: (data) => ({
+            ...data,
+            schemaVersion: 4,
+            ...(data["log"] === undefined ? { log: { enabled: true, directory: "" } } : {}),
+        }),
+    },
+    {
+        // v5 增加详情页缓存条数：默认缓存 20 个画廊，0 表示不缓存
+        from: 4,
+        to: 5,
+        migrate: (data) => {
+            const ui = (data["ui"] ?? {});
+            return {
+                ...data,
+                schemaVersion: 5,
+                ui: {
+                    ...ui,
+                    ...(ui["cachedGalleries"] === undefined ? { cachedGalleries: 20 } : {}),
+                },
+            };
+        },
+    },
+];
+export const AUTH_SETTING_MIGRATIONS = [];
+export const CURRENT_VERSIONS = {
+    user: USER_SETTING_VERSION,
+    auth: AUTH_SETTING_VERSION,
+};
+export function migrationsFor(file) {
+    return file === "user" ? USER_SETTING_MIGRATIONS : AUTH_SETTING_MIGRATIONS;
+}
+/** 将 data.schemaVersion 升至 target。缺失步骤直接抛错，避免写入不完整数据 */
+export function runMigrations(data, target, migrations) {
+    let current = data;
+    let version = readVersion(current);
+    const applied = [];
+    while (version < target) {
+        const step = migrations.find((m) => m.from === version);
+        if (step === undefined) {
+            throw new Error(`没有 v${version} → 更上层的迁移步骤，代码里的版本是 v${target}`);
+        }
+        current = step.migrate(current);
+        version = step.to;
+        applied.push(step.to);
+    }
+    return { data: current, applied };
+}
+/** 无法读取版本号时按 1 处理 */
+export function readVersion(data) {
+    const raw = data["schemaVersion"];
+    return typeof raw === "number" && Number.isInteger(raw) && raw >= 1 ? raw : 1;
+}

package/dist/config/schema.js

@@ -0,0 +1,108 @@
+/*
+ * 类型、默认值与字段表的唯一定义处。
+ * 字段变更涉及三处：本文件的类型/默认值/字段表、版本号、migrations.ts 中的迁移步骤。
+ */
+export const USER_SETTING_VERSION = 5;
+export const USER_SETTING_DEFAULTS = {
+    schemaVersion: USER_SETTING_VERSION,
+    locale: "zh-CN",
+    preferredSite: "e-hentai",
+    network: {
+        requestIntervalMs: 5000,
+        maxSequentialRequests: 5,
+        requestTimeoutMs: 30000,
+        proxy: {
+            enabled: false,
+            protocol: "http",
+            host: "127.0.0.1",
+            port: 7897,
+        },
+    },
+    viewer: {
+        mode: "mpv",
+        imageQuality: "org",
+        preloadCount: 2,
+        maxCacheMb: 512,
+        maxConcurrentLoads: 3,
+        autoplay: {
+            enabled: false,
+            intervalSeconds: 5,
+            loop: false,
+        },
+    },
+    translate: {
+        tags: false,
+    },
+    safety: {
+        // 默认落到空白页：未配置地点时，按快捷键也能立即替换屏幕内容
+        hintEnabled: true,
+        url: "about:blank",
+    },
+    download: {
+        directory: "",
+        keepArchive: true,
+        preferredResolution: "org",
+        concurrency: 2,
+    },
+    log: {
+        enabled: true,
+        // 空字符串有效：表示用默认目录
+        directory: "",
+    },
+    ui: {
+        theme: "system",
+        thumbnailSize: 250,
+        pageSize: 25,
+        cachedGalleries: 20,
+    },
+};
+export const USER_SETTING_FIELDS = [
+    { path: "schemaVersion", kind: "int", min: 1 },
+    { path: "locale", kind: "string", minLength: 2, maxLength: 20 },
+    { path: "preferredSite", kind: "enum", values: ["e-hentai", "exhentai"] },
+    { path: "network.requestIntervalMs", kind: "int", min: 1000, max: 60000 },
+    { path: "network.maxSequentialRequests", kind: "int", min: 1, max: 25 },
+    { path: "network.requestTimeoutMs", kind: "int", min: 1000, max: 300000 },
+    { path: "network.proxy.enabled", kind: "boolean" },
+    { path: "network.proxy.protocol", kind: "enum", values: ["http", "socks5"] },
+    { path: "network.proxy.host", kind: "string", minLength: 1, maxLength: 255 },
+    { path: "network.proxy.port", kind: "int", min: 1, max: 65535 },
+    { path: "viewer.mode", kind: "enum", values: ["mpv", "single"] },
+    { path: "viewer.imageQuality", kind: "enum", values: ["org", "res"] },
+    { path: "viewer.preloadCount", kind: "int", min: 0, max: 20 },
+    { path: "viewer.maxCacheMb", kind: "int", min: 64, max: 8192 },
+    { path: "viewer.maxConcurrentLoads", kind: "int", min: 1, max: 8 },
+    { path: "viewer.autoplay.enabled", kind: "boolean" },
+    { path: "viewer.autoplay.intervalSeconds", kind: "int", min: 1, max: 120 },
+    { path: "viewer.autoplay.loop", kind: "boolean" },
+    { path: "translate.tags", kind: "boolean" },
+    { path: "safety.hintEnabled", kind: "boolean" },
+    // 空字符串有效：表示未设置，按快捷键时落到空白页
+    { path: "safety.url", kind: "string", maxLength: 4096 },
+    // 空字符串有效，表示尚未设置
+    { path: "download.directory", kind: "string", maxLength: 4096 },
+    { path: "download.keepArchive", kind: "boolean" },
+    { path: "download.preferredResolution", kind: "string", minLength: 1, maxLength: 16 },
+    { path: "download.concurrency", kind: "int", min: 1, max: 8 },
+    { path: "log.enabled", kind: "boolean" },
+    // 空字符串有效，表示用默认目录
+    { path: "log.directory", kind: "string", maxLength: 4096 },
+    { path: "ui.theme", kind: "enum", values: ["system", "light", "dark"] },
+    { path: "ui.thumbnailSize", kind: "int", min: 100, max: 1000 },
+    { path: "ui.pageSize", kind: "int", min: 5, max: 100 },
+    { path: "ui.cachedGalleries", kind: "int", min: 0, max: 500 },
+];
+export const AUTH_SETTING_VERSION = 1;
+export const AUTH_SETTING_DEFAULTS = {
+    schemaVersion: AUTH_SETTING_VERSION,
+    activeAccountId: null,
+    accounts: [],
+    proxyAuth: { username: "", password: "" },
+};
+/** accounts 元素不在此校验，结构可变，由 auth-setting.ts 逐项校验 */
+export const AUTH_SETTING_FIELDS = [
+    { path: "schemaVersion", kind: "int", min: 1 },
+    { path: "activeAccountId", kind: "string", optional: true },
+    { path: "proxyAuth.username", kind: "string", maxLength: 255 },
+    { path: "proxyAuth.password", kind: "string", maxLength: 255 },
+];

package/dist/config/user-setting.js

@@ -0,0 +1,21 @@
+/* user_setting.json 的接线，不含业务逻辑 */
+import { join } from "node:path";
+import { getPaths } from "../platform/paths.js";
+import { createJsonStore } from "./json-store.js";
+import { USER_SETTING_MIGRATIONS } from "./migrations.js";
+import { USER_SETTING_DEFAULTS, USER_SETTING_FIELDS } from "./schema.js";
+export const USER_SETTING_FILENAME = "user_setting.json";
+export function userSettingFile(configDir = getPaths().configDir) {
+    return join(configDir, USER_SETTING_FILENAME);
+}
+/** 权限 0644。文件不含密钥，用户可以直接编辑或分享。 */
+export function createUserSettingStore(options = {}) {
+    return createJsonStore({
+        file: options.file ?? userSettingFile(),
+        defaults: USER_SETTING_DEFAULTS,
+        fields: USER_SETTING_FIELDS,
+        migrations: USER_SETTING_MIGRATIONS,
+        mode: 0o644,
+        logger: options.logger,
+    });
+}

package/dist/config/validate.js

@@ -0,0 +1,173 @@
+/*
+ * 字段级校验与对象工具。
+ * 仅处理结构：类型、枚举、范围。跨字段约束（如启用代理需填写主机）属于 services 层。
+ */
+const INVALID = { ok: false, issues: [] };
+export function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** 读取点分路径，不存在时返回 undefined。 */
+export function getAtPath(root, path) {
+    let current = root;
+    for (const key of path.split(".")) {
+        if (!isPlainObject(current)) {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+}
+/** 写入点分路径，缺失的中间对象自动创建 */
+export function setAtPath(root, path, value) {
+    const keys = path.split(".");
+    const last = keys.pop();
+    if (last === undefined) {
+        return;
+    }
+    let current = root;
+    for (const key of keys) {
+        const next = current[key];
+        if (!isPlainObject(next)) {
+            const created = {};
+            current[key] = created;
+            current = created;
+        }
+        else {
+            current = next;
+        }
+    }
+    current[last] = value;
+}
+/** 深合并：仅覆盖 overlay 中出现的键。数组整体替换，不逐项合并 */
+export function deepMerge(base, overlay) {
+    if (!isPlainObject(base) || !isPlainObject(overlay)) {
+        return (overlay === undefined ? base : overlay);
+    }
+    const out = { ...base };
+    for (const [key, value] of Object.entries(overlay)) {
+        out[key] = key in out ? deepMerge(out[key], value) : value;
+    }
+    return out;
+}
+/** 返回 patch 中未声明的路径。未声明字段会被原样写入配置文件，因此在入口拦截 */
+export function collectUnknownPaths(patch, known, prefix = "") {
+    if (!isPlainObject(patch) || !isPlainObject(known)) {
+        return [];
+    }
+    const out = [];
+    for (const [key, value] of Object.entries(patch)) {
+        const path = prefix === "" ? key : `${prefix}.${key}`;
+        if (!(key in known)) {
+            out.push(path);
+            continue;
+        }
+        out.push(...collectUnknownPaths(value, known[key], path));
+    }
+    return out;
+}
+/** 一次校验一组字段 */
+export function validateFields(value, fields) {
+    const issues = [];
+    for (const field of fields) {
+        const current = getAtPath(value, field.path);
+        if (current === undefined || current === null) {
+            if (field.optional !== true) {
+                issues.push({ path: field.path, code: "missing", message: "缺少该字段" });
+            }
+            continue;
+        }
+        const issue = checkField(field, current);
+        if (issue !== null) {
+            issues.push(issue);
+        }
+    }
+    return issues.length === 0 ? { ok: true, value: value } : { ok: false, issues };
+}
+/** 坏值就地替换为默认值，返回替换项。用于配置损坏时仍可启动。 */
+export function repairFields(target, defaults, fields) {
+    const issues = [];
+    for (const field of fields) {
+        const current = getAtPath(target, field.path);
+        if (current === undefined || current === null) {
+            if (field.optional !== true) {
+                issues.push({ path: field.path, code: "missing", message: "缺少该字段" });
+                const fallback = getAtPath(defaults, field.path);
+                if (fallback !== undefined) {
+                    setAtPath(target, field.path, fallback);
+                }
+            }
+            continue;
+        }
+        const issue = checkField(field, current);
+        if (issue === null) {
+            continue;
+        }
+        issues.push(issue);
+        const fallback = getAtPath(defaults, field.path);
+        if (fallback !== undefined) {
+            setAtPath(target, field.path, fallback);
+        }
+    }
+    return issues;
+}
+function checkField(field, current) {
+    const bad = (code, message) => ({
+        path: field.path,
+        code,
+        message,
+    });
+    switch (field.kind) {
+        case "string": {
+            if (typeof current !== "string") {
+                return bad("type", "类型应为字符串");
+            }
+            if (field.minLength !== undefined && current.length < field.minLength) {
+                return bad("range", `长度不应小于 ${field.minLength}`);
+            }
+            if (field.maxLength !== undefined && current.length > field.maxLength) {
+                return bad("range", `长度不应超过 ${field.maxLength}`);
+            }
+            return null;
+        }
+        case "int":
+        case "number": {
+            if (typeof current !== "number" || !Number.isFinite(current)) {
+                return bad("type", "类型应为数字");
+            }
+            if (field.kind === "int" && !Number.isInteger(current)) {
+                return bad("type", "类型应为整数");
+            }
+            if (field.min !== undefined && current < field.min) {
+                return bad("range", `数值不应小于 ${field.min}`);
+            }
+            if (field.max !== undefined && current > field.max) {
+                return bad("range", `数值不应大于 ${field.max}`);
+            }
+            return null;
+        }
+        case "boolean": {
+            return typeof current === "boolean" ? null : bad("type", "类型应为布尔值");
+        }
+        case "enum": {
+            const values = field.values ?? [];
+            if (typeof current !== "string" || !values.includes(current)) {
+                return bad("enum", `取值必须是 ${values.join(" / ")}`);
+            }
+            return null;
+        }
+        case "stringArray": {
+            if (!Array.isArray(current) || current.some((item) => typeof item !== "string")) {
+                return bad("type", "类型应为字符串数组");
+            }
+            return null;
+        }
+        case "enumArray": {
+            const values = field.values ?? [];
+            if (!Array.isArray(current) ||
+                current.some((item) => !values.includes(item))) {
+                return bad("enum", `元素取值必须是 ${values.join(" / ")}`);
+            }
+            return null;
+        }
+    }
+}

package/dist/eh/api.js

@@ -0,0 +1,106 @@
+/*
+ * 上游接口封装：gdata / gtoken / showpage。
+ * 请求体与响应字段名保持上游原样；单次上限 25 条，超出自动分批。
+ * 图片地址来自 showpage 的片段解析，静态 HTML 里没有。
+ */
+import { callApiJson } from "./http.js";
+import { MAX_ENTRIES_PER_REQUEST, UPSTREAM_API, } from "./types.js";
+/** 图库元数据。返回顺序与入参一致，失败条目带 error 字段而非抛错 */
+export async function gdata(pairs, options = {}) {
+    const collected = [];
+    for (const part of chunked(pairs, MAX_ENTRIES_PER_REQUEST)) {
+        const response = await callApiJson({
+            ...requestOf(options),
+            body: JSON.stringify({
+                method: "gdata",
+                gidlist: part.map(([gid, token]) => [gid, token]),
+                // 带上命名空间前缀，返回形如 "female:stockings"
+                namespace: 1,
+            }),
+        });
+        if (response.gmetadata === undefined) {
+            throw new Error("gdata 响应缺少 gmetadata");
+        }
+        collected.push(...response.gmetadata);
+    }
+    return collected;
+}
+/** 由图片页链接反查画廊 token。返回顺序与入参一致，失败条目带 error 字段 */
+export async function gtoken(pages, options = {}) {
+    const collected = [];
+    for (const part of chunked(pages, MAX_ENTRIES_PER_REQUEST)) {
+        const response = await callApiJson({
+            ...requestOf(options),
+            body: JSON.stringify({
+                method: "gtoken",
+                pagelist: part.map(([gid, pageToken, page]) => [gid, pageToken, page]),
+            }),
+        });
+        if (response.tokenlist === undefined) {
+            throw new Error("gtoken 响应缺少 tokenlist");
+        }
+        collected.push(...response.tokenlist);
+    }
+    return collected;
+}
+/** 取单页图片地址。上游以 error 字段报错时抛出 */
+export async function showpage(input, options = {}) {
+    const response = await callApiJson({
+        ...requestOf(options),
+        body: JSON.stringify({
+            method: "showpage",
+            gid: input.gid,
+            page: input.page,
+            imgkey: input.imgkey,
+            showkey: input.showkey,
+        }),
+    });
+    if (response.error !== undefined) {
+        throw new Error(`showpage 失败：${response.error}`);
+    }
+    const imageUrl = matchGroup(response.i3 ?? "", /<img[^>]*src="([^"]+)" style/);
+    if (imageUrl === null) {
+        throw new Error("showpage 响应中未找到图片地址");
+    }
+    const origin = (response.i7 ?? "").match(/<a href="([^"]+)fullimg\.php([^"]+)">/);
+    const skipHathKey = matchGroup(response.i6 ?? "", /onclick="return nl\('([^)]+)'\)/);
+    return {
+        imageUrl: decodeEntities(imageUrl),
+        originalImageUrl: origin === null ? null : decodeEntities(`${origin[1]}fullimg.php${origin[2]}`),
+        skipHathKey: skipHathKey === null ? null : decodeEntities(skipHathKey),
+    };
+}
+function requestOf(options) {
+    const site = options.site ?? "e-hentai";
+    const request = { url: UPSTREAM_API[site], method: "POST", site };
+    if (options.cookies !== undefined) {
+        request.cookies = options.cookies;
+    }
+    if (options.timeoutMs !== undefined) {
+        request.timeoutMs = options.timeoutMs;
+    }
+    if (options.signal !== undefined) {
+        request.signal = options.signal;
+    }
+    return request;
+}
+function chunked(items, size) {
+    const out = [];
+    for (let index = 0; index < items.length; index += size) {
+        out.push(items.slice(index, index + size));
+    }
+    return out.length === 0 ? [] : out;
+}
+function matchGroup(text, pattern) {
+    const found = pattern.exec(text);
+    return found === null ? null : (found[1] ?? null);
+}
+/** 上游片段里的 XML 实体 */
+function decodeEntities(text) {
+    return text
+        .replaceAll("&lt;", "<")
+        .replaceAll("&gt;", ">")
+        .replaceAll("&quot;", '"')
+        .replaceAll("&#39;", "'")
+        .replaceAll("&amp;", "&");
+}

package/dist/eh/archives.js

@@ -0,0 +1,100 @@
+/*
+ * 归档相关接口：列表与下载地址。
+ *
+ * 流程分两步：先取列表（含各分辨率与账户资金），再按分辨率请求下载地址。
+ *
+ * 需要登录。未登录时上游返回登录页而非 JSON。
+ */
+import { parseArchiveList } from "./html.js";
+import { callApi, isLoginRequired, LoginRequiredError } from "./http.js";
+import { siteOrigin } from "./urls.js";
+function archiverUrl(site, gid, token) {
+    return `${siteOrigin(site)}/archiver.php?gid=${gid}&token=${encodeURIComponent(token)}`;
+}
+function requestOf(options, url) {
+    const base = {
+        url,
+        method: "POST",
+        site: options.site,
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body: "",
+    };
+    return {
+        ...base,
+        ...(options.cookies === undefined ? {} : { cookies: options.cookies }),
+        ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+        ...(options.signal === undefined ? {} : { signal: options.signal }),
+    };
+}
+/** 归档列表。解析失败时抛错，调用方据此判断是否需要登录 */
+export async function fetchArchiveCatalog(gid, token, options) {
+    const response = await callApi(requestOf(options, archiverUrl(options.site, gid, token)));
+    if (isLoginRequired(response)) {
+        throw new LoginRequiredError("归档列表需要登录后查看");
+    }
+    const parsed = parseArchiveList(response.text);
+    if (parsed === null) {
+        throw new Error(`归档列表解析失败（HTTP ${response.status}），通常表示未登录或会话已失效`);
+    }
+    return parsed;
+}
+export function buildArchiveForm(resolution, viaHath) {
+    if (viaHath) {
+        // H@H 下载器：由 H@H 客户端在后台取回，不直接给下载地址
+        return { hathdl_xres: resolution };
+    }
+    return {
+        dltype: resolution,
+        dlcheck: resolution === "org" ? "Download Original Archive" : "Download Resample Archive",
+    };
+}
+/**
+ * 请求归档下载地址。普通下载返回直链；H@H 下载返回 null（由客户端另行取回）
+ * 服务端打包需要时间，首次可能拿不到地址，故允许重试
+ */
+export async function resolveArchiveUrl(gid, token, resolution, viaHath, options) {
+    if (viaHath) {
+        const response = await callApi({
+            ...requestOf(options, archiverUrl(options.site, gid, token)),
+            body: new URLSearchParams(buildArchiveForm(resolution, true)).toString(),
+        });
+        if (isLoginRequired(response)) {
+            throw new LoginRequiredError("H@H 下载需要登录，请在账号页登录后重试");
+        }
+        if (response.status !== 200) {
+            throw new Error(`H@H 下载请求失败：HTTP ${response.status}`);
+        }
+        return null;
+    }
+    const body = new URLSearchParams(buildArchiveForm(resolution, false)).toString();
+    const response = await callApi({
+        ...requestOf(options, archiverUrl(options.site, gid, token)),
+        body,
+    });
+    if (isLoginRequired(response)) {
+        throw new LoginRequiredError("归档下载需要登录，请在账号页登录后重试");
+    }
+    const url = extractUrl(response.text);
+    if (url === null) {
+        throw new Error(`未取到归档地址（HTTP ${response.status}）：${response.text.slice(0, 120)}`);
+    }
+    return url;
+}
+/** 响应可能是 JSON（含 url 字段）或直接的地址文本 */
+function extractUrl(text) {
+    const trimmed = text.trim();
+    if (trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            const candidate = parsed["url"] ?? parsed["archive_url"] ?? parsed["download"];
+            if (typeof candidate === "string" && candidate.startsWith("http")) {
+                return candidate;
+            }
+        }
+        catch {
+            return null;
+        }
+        return null;
+    }
+    return trimmed.startsWith("http") ? trimmed : null;
+}