jav-manager 0.1.0

package/dist/utils/curlBinaryResolver.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurlImpersonateBinaryPath = getCurlImpersonateBinaryPath;
+exports.getCurlCaBundlePath = getCurlCaBundlePath;
+exports.checkCurlImpersonateAvailable = checkCurlImpersonateAvailable;
+exports.getAvailableTargets = getAvailableTargets;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+function resolvePathMaybeRelative(filePath) {
+    if (!filePath) {
+        return filePath;
+    }
+    if (path_1.default.isAbsolute(filePath)) {
+        return filePath;
+    }
+    return path_1.default.resolve(process.cwd(), filePath);
+}
+function isExecutableFile(filePath) {
+    try {
+        const stat = fs_1.default.statSync(filePath);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function findOnPath(fileName) {
+    const envPath = process.env.PATH ?? "";
+    const sep = process.platform === "win32" ? ";" : ":";
+    const entries = envPath
+        .split(sep)
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0);
+    for (const dir of entries) {
+        const candidate = path_1.default.join(dir, fileName);
+        if (isExecutableFile(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+/**
+ * Get the platform-specific curl-impersonate binary path
+ */
+function getCurlImpersonateBinaryPath(target = "chrome116", configuredPath = null) {
+    if (configuredPath && configuredPath.trim()) {
+        return resolvePathMaybeRelative(configuredPath.trim());
+    }
+    const platform = process.platform;
+    const arch = process.arch;
+    // Map platform/arch to binary path in third_party/curl-impersonate/
+    const binaryMap = {
+        win32: {
+            x64: path_1.default.join("third_party", "curl-impersonate", "bin", `curl_${target}.exe`),
+            arm64: path_1.default.join("third_party", "curl-impersonate", "bin", `curl_${target}.exe`),
+        },
+        linux: {
+            x64: path_1.default.join("third_party", "curl-impersonate", "bin", `curl_${target}`),
+            arm64: path_1.default.join("third_party", "curl-impersonate", "bin", `curl_${target}`),
+        },
+        darwin: {
+            x64: path_1.default.join("third_party", "curl-impersonate", "bin", `curl_${target}`),
+            arm64: path_1.default.join("third_party", "curl-impersonate", "bin", `curl_${target}`),
+        },
+    };
+    const platformBinaries = binaryMap[platform];
+    if (!platformBinaries) {
+        return null;
+    }
+    const binaryPath = platformBinaries[arch] || platformBinaries.x64;
+    return resolvePathMaybeRelative(binaryPath);
+}
+/**
+ * Get the CA bundle path for curl-impersonate
+ */
+function getCurlCaBundlePath(configuredPath = null) {
+    if (configuredPath && fs_1.default.existsSync(configuredPath)) {
+        return configuredPath;
+    }
+    const platform = process.platform;
+    const arch = process.arch;
+    // Map platform/arch to CA bundle path in native/curl-impersonate/
+    const caBundleMap = {
+        win32: {
+            x64: path_1.default.join("native", "curl-impersonate", "win-x64", "cacert.pem"),
+            arm64: path_1.default.join("native", "curl-impersonate", "win-arm64", "cacert.pem"),
+        },
+        linux: {
+            x64: path_1.default.join("native", "curl-impersonate", "linux-x64", "cacert.pem"),
+            arm64: path_1.default.join("native", "curl-impersonate", "linux-arm64", "cacert.pem"),
+        },
+        darwin: {
+            x64: path_1.default.join("native", "curl-impersonate", "osx-x64", "cacert.pem"),
+            arm64: path_1.default.join("native", "curl-impersonate", "osx-arm64", "cacert.pem"),
+        },
+    };
+    const platformCaBundles = caBundleMap[platform];
+    if (!platformCaBundles) {
+        return null;
+    }
+    const caBundlePath = platformCaBundles[arch] || platformCaBundles.x64;
+    if (fs_1.default.existsSync(caBundlePath)) {
+        return caBundlePath;
+    }
+    return null;
+}
+/**
+ * Check if curl-impersonate binary is available
+ */
+function checkCurlImpersonateAvailable(target = "chrome116", configuredPath = null) {
+    const binaryPath = getCurlImpersonateBinaryPath(target, configuredPath);
+    if (!binaryPath) {
+        return { path: "", exists: false, target };
+    }
+    const existsOnDisk = fs_1.default.existsSync(binaryPath);
+    if (existsOnDisk) {
+        return { path: binaryPath, exists: true, target };
+    }
+    // Windows fallback: allow vendored Linux binaries (to be run via WSL) when the .exe doesn't exist.
+    if (process.platform === "win32" && binaryPath.toLowerCase().endsWith(".exe")) {
+        const alt = binaryPath.slice(0, -4);
+        if (alt && fs_1.default.existsSync(alt)) {
+            return { path: alt, exists: true, target };
+        }
+    }
+    // Allow PATH-installed curl_<target> binaries (useful when vendoring isn't available).
+    const fileName = process.platform === "win32" ? `curl_${target}.exe` : `curl_${target}`;
+    const found = findOnPath(fileName);
+    if (found) {
+        return { path: found, exists: true, target };
+    }
+    return {
+        path: binaryPath,
+        exists: false,
+        target,
+    };
+}
+/**
+ * Get available curl-impersonate targets
+ */
+function getAvailableTargets() {
+    const targets = ["chrome116", "chrome120", "chrome131", "chrome136", "chrome144", "firefox133", "firefox135"];
+    const available = [];
+    for (const target of targets) {
+        const info = checkCurlImpersonateAvailable(target, null);
+        if (info.exists) {
+            available.push(target);
+        }
+    }
+    return available;
+}

package/dist/utils/httpHelper.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpHelper = void 0;
+class HttpHelper {
+    defaultHeaders = new Map();
+    setDefaultHeader(name, value) {
+        this.defaultHeaders.set(name, value);
+    }
+    removeDefaultHeader(name) {
+        this.defaultHeaders.delete(name);
+    }
+    setBasicAuth(userName, password) {
+        const credentials = Buffer.from(`${userName}:${password}`).toString("base64");
+        this.setDefaultHeader("Authorization", `Basic ${credentials}`);
+    }
+    async get(url, headers, timeoutMs) {
+        const response = await this.request("GET", url, { headers, timeoutMs });
+        if (response.status < 200 || response.status >= 300) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        return response.text;
+    }
+    async post(url, formData, headers, timeoutMs) {
+        const body = new URLSearchParams(formData).toString();
+        const response = await this.request("POST", url, {
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+                ...(headers ?? {}),
+            },
+            body,
+            timeoutMs,
+        });
+        if (response.status < 200 || response.status >= 300) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        return response.text;
+    }
+    async postMultipart(url, formData, headers, timeoutMs) {
+        const data = new FormData();
+        for (const [key, value] of Object.entries(formData)) {
+            data.append(key, value ?? "");
+        }
+        const response = await this.request("POST", url, { headers, body: data, timeoutMs });
+        if (response.status < 200 || response.status >= 300) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        return response.text;
+    }
+    async request(method, url, options = {}) {
+        const headers = new Headers();
+        for (const [key, value] of this.defaultHeaders.entries()) {
+            headers.set(key, value);
+        }
+        if (options.headers) {
+            for (const [key, value] of Object.entries(options.headers)) {
+                headers.set(key, value);
+            }
+        }
+        const controller = new AbortController();
+        const timeout = options.timeoutMs ? setTimeout(() => controller.abort(), options.timeoutMs) : null;
+        try {
+            const response = await fetch(url, {
+                method,
+                headers,
+                body: options.body,
+                signal: controller.signal,
+            });
+            const text = await response.text();
+            return { status: response.status, text, headers: response.headers };
+        }
+        finally {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+        }
+    }
+}
+exports.HttpHelper = HttpHelper;

package/dist/utils/platformShell.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openContainingFolder = openContainingFolder;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const open_1 = __importDefault(require("open"));
+async function openContainingFolder(targetPath) {
+    if (!targetPath) {
+        return;
+    }
+    const resolved = path_1.default.resolve(targetPath);
+    const stat = fs_1.default.existsSync(resolved) ? fs_1.default.statSync(resolved) : null;
+    const folder = stat && stat.isDirectory() ? resolved : path_1.default.dirname(resolved);
+    await (0, open_1.default)(folder);
+}

package/dist/utils/sizeParser.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mb = mb;
+exports.tryParseToBytes = tryParseToBytes;
+const unitMap = {
+    B: 1,
+    KB: 1024,
+    KIB: 1024,
+    K: 1024,
+    MB: 1024 * 1024,
+    MIB: 1024 * 1024,
+    M: 1024 * 1024,
+    GB: 1024 * 1024 * 1024,
+    GIB: 1024 * 1024 * 1024,
+    G: 1024 * 1024 * 1024,
+    TB: 1024 * 1024 * 1024 * 1024,
+    TIB: 1024 * 1024 * 1024 * 1024,
+    T: 1024 * 1024 * 1024 * 1024,
+};
+function mb(value) {
+    return value * 1024 * 1024;
+}
+function tryParseToBytes(text) {
+    if (!text) {
+        return null;
+    }
+    const input = text.trim();
+    if (!input) {
+        return null;
+    }
+    if (/^\d+$/.test(input)) {
+        return Number(input);
+    }
+    const match = input.match(/^\s*(\d+(?:\.\d+)?)\s*(B|KB|MB|GB|TB|KIB|MIB|GIB|TIB|K|M|G|T)\s*$/i);
+    if (!match) {
+        return null;
+    }
+    const value = Number(match[1]);
+    if (Number.isNaN(value) || value < 0) {
+        return null;
+    }
+    const unit = match[2].toUpperCase();
+    const multiplier = unitMap[unit];
+    if (!multiplier) {
+        return null;
+    }
+    return Math.floor(value * multiplier);
+}

package/dist/utils/telemetryEndpoints.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTelemetryPostUrl = getTelemetryPostUrl;
+exports.getJavInfoPostUrl = getJavInfoPostUrl;
+exports.getBaseEndpoint = getBaseEndpoint;
+exports.normalizeBaseEndpointOrNull = normalizeBaseEndpointOrNull;
+const DefaultBaseEndpoint = "https://jav-manager.techfetch.dev";
+function getTelemetryPostUrl(endpoint) {
+    return `${getBaseEndpoint(endpoint)}/api/telemetry`;
+}
+function getJavInfoPostUrl(endpoint) {
+    return `${getBaseEndpoint(endpoint)}/api/javinfo`;
+}
+function getBaseEndpoint(endpoint) {
+    const normalized = normalizeBaseEndpointOrNull(endpoint);
+    return normalized || DefaultBaseEndpoint;
+}
+function normalizeBaseEndpointOrNull(endpoint) {
+    if (!endpoint || !String(endpoint).trim()) {
+        return null;
+    }
+    const raw = String(endpoint).trim();
+    let parsed;
+    try {
+        parsed = new URL(raw);
+    }
+    catch {
+        return raw.replace(/\/+$/, "");
+    }
+    let path = parsed.pathname.replace(/\/+$/, "");
+    if (path.toLowerCase().endsWith("/api/telemetry")) {
+        path = path.slice(0, -"/api/telemetry".length);
+    }
+    else if (path.toLowerCase().endsWith("/api/javinfo")) {
+        path = path.slice(0, -"/api/javinfo".length);
+    }
+    else if (path.toLowerCase().endsWith("/api")) {
+        path = path.slice(0, -"/api".length);
+    }
+    parsed.pathname = path.replace(/\/+$/, "") || "/";
+    parsed.search = "";
+    parsed.hash = "";
+    return parsed.toString().replace(/\/+$/, "");
+}

package/dist/utils/torrentNameParser.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTorrentName = parseTorrentName;
+exports.normalizeJavId = normalizeJavId;
+exports.isValidJavId = isValidJavId;
+const models_1 = require("../models");
+const uncensoredRegex = /-(?:UC|U)(?=$|[^A-Za-z0-9])/i;
+function parseTorrentName(torrentName) {
+    let uncensoredType = models_1.UncensoredMarkerType.None;
+    const hasSubtitle = false;
+    const match = torrentName.match(uncensoredRegex);
+    if (match) {
+        const marker = match[0].toUpperCase();
+        if (marker === "-UC") {
+            uncensoredType = models_1.UncensoredMarkerType.UC;
+        }
+        else if (marker === "-U") {
+            uncensoredType = models_1.UncensoredMarkerType.U;
+        }
+    }
+    if (uncensoredType === models_1.UncensoredMarkerType.None &&
+        (torrentName.toLowerCase().includes("无码") ||
+            torrentName.toLowerCase().includes("無碼") ||
+            torrentName.toLowerCase().includes("uncensored"))) {
+        uncensoredType = models_1.UncensoredMarkerType.U;
+    }
+    return { uncensoredType, hasSubtitle };
+}
+function normalizeJavId(javId) {
+    const normalized = javId.trim().replace(/_/g, "-").toUpperCase();
+    const noSpaces = normalized.replace(/\s+/g, "");
+    if (/^[A-Z0-9]+-\d+$/.test(noSpaces)) {
+        return noSpaces;
+    }
+    const extractable = normalized.replace(/[^A-Z0-9-]+/g, " ");
+    const match = extractable.match(/\b[A-Z0-9]+-\d+\b/);
+    if (match) {
+        return match[0];
+    }
+    return noSpaces;
+}
+function isValidJavId(javId) {
+    return /^[A-Z0-9]+-\d+$/i.test(javId);
+}

package/dist/utils/weightCalculator.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateWeight = calculateWeight;
+exports.calculateAndSort = calculateAndSort;
+const UC_SCORE = 5;
+const SUB_SCORE = 3;
+const HD_SCORE = 1;
+const titleUncensoredRegex = /-(?:UC|U)(?=$|[^A-Za-z0-9])/i;
+function calculateWeight(torrent) {
+    const hasUncensored = torrent.hasUncensoredMarker || titleUncensoredRegex.test(torrent.title);
+    let score = 0;
+    if (hasUncensored)
+        score += UC_SCORE;
+    if (torrent.hasSubtitle)
+        score += SUB_SCORE;
+    if (torrent.hasHd)
+        score += HD_SCORE;
+    // Keep derived field consistent with marker fallback, so downstream logic uses the same view.
+    torrent.hasUncensoredMarker = hasUncensored;
+    torrent.weightScore = score;
+    return score;
+}
+function calculateAndSort(torrents) {
+    for (const torrent of torrents) {
+        calculateWeight(torrent);
+    }
+    return torrents
+        .slice()
+        .sort((a, b) => {
+        if (a.weightScore !== b.weightScore) {
+            return b.weightScore - a.weightScore;
+        }
+        if (a.size !== b.size) {
+            return b.size - a.size;
+        }
+        return a.title.localeCompare(b.title);
+    });
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "jav-manager",
+  "version": "0.1.0",
+  "private": false,
+  "description": "TypeScript rewrite of JavManager",
+  "main": "dist/index.js",
+  "bin": {
+    "jav-manager": "bin/jav-manager.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "cli": "node dist/index.js --no-gui",
+    "gui": "node dist/index.js",
+    "dev:cli": "ts-node src/index.ts --no-gui",
+    "dev:gui": "ts-node src/index.ts",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && node --test test/*.test.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "type": "commonjs",
+  "dependencies": {
+    "cheerio": "^1.2.0",
+    "express": "^5.2.1",
+    "open": "^11.0.0"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.2.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}