3ed3877ac9
Strip every comment from the source (parsed with the TypeScript compiler so strings, template literals, regex literals and JSX are never touched), and drop internal/working artifacts that do not belong in the public repository (design mockups, internal analysis docs, a stray backup file and an old log). No functional change: build is green, the full test suite passes.
3422 lines
130 KiB
TypeScript
3422 lines
130 KiB
TypeScript
import fs from "node:fs";
|
|
import path from "node:path";
|
|
import os from "node:os";
|
|
import { spawn, spawnSync, type ChildProcess } from "node:child_process";
|
|
import AdmZip from "adm-zip";
|
|
import { CleanupMode, ConflictMode } from "../shared/types";
|
|
import { logger } from "./logger";
|
|
import { removeDownloadLinkArtifacts, removeSampleArtifacts } from "./cleanup";
|
|
|
|
import crypto from "node:crypto";
|
|
|
|
const DEFAULT_ARCHIVE_PASSWORDS = ["", "serienfans.org", "serienjunkies.org"];
|
|
const NO_EXTRACTOR_MESSAGE = "Kein nativer Entpacker gefunden (7-Zip/WinRAR). Bitte 7-Zip oder WinRAR installieren.";
|
|
const NO_JVM_EXTRACTOR_MESSAGE = "7-Zip-JBinding Runtime nicht gefunden. Bitte resources/extractor-jvm prüfen.";
|
|
const JVM_EXTRACTOR_MAIN_CLASS = "com.sucukdeluxe.extractor.JBindExtractorMain";
|
|
const JVM_EXTRACTOR_CLASSES_SUBDIR = "classes";
|
|
const JVM_EXTRACTOR_LIB_SUBDIR = "lib";
|
|
const JVM_EXTRACTOR_REQUIRED_LIBS = [
|
|
"sevenzipjbinding.jar",
|
|
"sevenzipjbinding-all-platforms.jar",
|
|
"zip4j.jar"
|
|
];
|
|
|
|
let resolvedExtractorCommand: string | null = null;
|
|
let resolveFailureReason = "";
|
|
let resolveFailureAt = 0;
|
|
let externalExtractorSupportsPerfFlags = true;
|
|
let resolveExtractorCommandInFlight: Promise<string> | null = null;
|
|
|
|
const EXTRACTOR_RETRY_AFTER_MS = 30_000;
|
|
const DEFAULT_ZIP_ENTRY_MEMORY_LIMIT_MB = 256;
|
|
const MAX_EXTRACT_OUTPUT_BUFFER = 48 * 1024;
|
|
const EXTRACT_PROGRESS_FILE = ".rd_extract_progress.json";
|
|
const EXTRACT_BASE_TIMEOUT_MS = 6 * 60 * 1000;
|
|
const EXTRACT_PER_GIB_TIMEOUT_MS = 4 * 60 * 1000;
|
|
const EXTRACT_MAX_TIMEOUT_MS = 120 * 60 * 1000;
|
|
const ARCHIVE_SORT_COLLATOR = new Intl.Collator(undefined, { numeric: true, sensitivity: "base" });
|
|
const DISK_SPACE_SAFETY_FACTOR = 1.1;
|
|
const NESTED_EXTRACT_BLACKLIST_RE = /\.(iso|img|bin|dmg|vhd|vhdx|vmdk|wim)$/i;
|
|
const PACKAGE_PASSWORD_CACHE_LIMIT = 256;
|
|
const packageLearnedPasswords = new Map<string, string>();
|
|
const EXTRACTOR_PROBE_TIMEOUT_MS = 8_000;
|
|
const DEFAULT_EXTRACT_CPU_BUDGET_PERCENT = 80;
|
|
let currentExtractCpuPriority: string | undefined;
|
|
|
|
export interface ExtractOptions {
|
|
packageDir: string;
|
|
targetDir: string;
|
|
cleanupMode: CleanupMode;
|
|
conflictMode: ConflictMode;
|
|
removeLinks: boolean;
|
|
removeSamples: boolean;
|
|
passwordList?: string;
|
|
signal?: AbortSignal;
|
|
onProgress?: (update: ExtractProgressUpdate) => void;
|
|
onlyArchives?: Set<string>;
|
|
skipPostCleanup?: boolean;
|
|
packageId?: string;
|
|
hybridMode?: boolean;
|
|
maxParallel?: number;
|
|
extractCpuPriority?: string;
|
|
onArchiveFailure?: (failure: ExtractArchiveFailureInfo) => void;
|
|
onLog?: (level: "INFO" | "WARN" | "ERROR", message: string) => void;
|
|
}
|
|
|
|
export interface ExtractProgressUpdate {
|
|
current: number;
|
|
total: number;
|
|
percent: number;
|
|
archiveName: string;
|
|
archivePercent?: number;
|
|
elapsedMs?: number;
|
|
phase: "extracting" | "done" | "preparing";
|
|
passwordAttempt?: number;
|
|
passwordTotal?: number;
|
|
passwordFound?: boolean;
|
|
archiveDone?: boolean;
|
|
archiveSuccess?: boolean;
|
|
}
|
|
|
|
export interface ExtractArchiveFailureInfo {
|
|
archiveName: string;
|
|
errorText: string;
|
|
category: ExtractErrorCategory;
|
|
suggestRedownload: boolean;
|
|
jvmFailureReason?: string;
|
|
}
|
|
|
|
export type ArchiveSignature = "rar" | "7z" | "zip" | "gzip" | "bzip2" | "xz" | null;
|
|
|
|
const ARCHIVE_SIGNATURES: { prefix: string; type: ArchiveSignature }[] = [
|
|
{ prefix: "526172211a07", type: "rar" },
|
|
{ prefix: "377abcaf271c", type: "7z" },
|
|
{ prefix: "504b0304", type: "zip" },
|
|
{ prefix: "1f8b08", type: "gzip" },
|
|
{ prefix: "425a68", type: "bzip2" },
|
|
{ prefix: "fd377a585a00", type: "xz" },
|
|
];
|
|
|
|
export type ExtractErrorCategory =
|
|
| "crc_error"
|
|
| "wrong_password"
|
|
| "missing_parts"
|
|
| "unsupported_format"
|
|
| "disk_full"
|
|
| "timeout"
|
|
| "aborted"
|
|
| "no_extractor"
|
|
| "unknown";
|
|
|
|
type ExtractionErrorWithHints = Error & {
|
|
suggestRedownload?: boolean;
|
|
jvmFailureReason?: string;
|
|
legacyBestPercent?: number;
|
|
legacyExtractor?: string;
|
|
};
|
|
|
|
type ExtractBackendMode = "auto" | "jvm" | "legacy";
|
|
|
|
type JvmExtractorLayout = {
|
|
javaCommand: string;
|
|
classPath: string;
|
|
rootDir: string;
|
|
};
|
|
|
|
type JvmExtractResult = {
|
|
ok: boolean;
|
|
missingCommand: boolean;
|
|
missingRuntime: boolean;
|
|
aborted: boolean;
|
|
timedOut: boolean;
|
|
errorText: string;
|
|
usedPassword: string;
|
|
backend: string;
|
|
};
|
|
|
|
type ExtractSpawnResult = {
|
|
ok: boolean;
|
|
missingCommand: boolean;
|
|
aborted: boolean;
|
|
timedOut: boolean;
|
|
errorText: string;
|
|
};
|
|
|
|
type ExtractResumeState = {
|
|
completedArchives: string[];
|
|
};
|
|
|
|
type ExtractorCommandKind = "rar_native" | "seven_zip" | "other";
|
|
|
|
interface SubstMapping { drive: string; original: string; }
|
|
|
|
interface DaemonRequest {
|
|
resolve: (result: JvmExtractResult) => void;
|
|
onArchiveProgress?: (percent: number) => void;
|
|
signal?: AbortSignal;
|
|
timeoutMs?: number;
|
|
parseState: { bestPercent: number; usedPassword: string; backend: string; reportedError: string };
|
|
archiveName: string;
|
|
startedAt: number;
|
|
passwordCount: number;
|
|
}
|
|
|
|
const activeSubstDrives = new Set<string>();
|
|
|
|
function findFreeSubstDrive(): string | null {
|
|
if (process.platform !== "win32") return null;
|
|
for (let code = 90; code >= 71; code--) {
|
|
const letter = String.fromCharCode(code);
|
|
if (activeSubstDrives.has(letter)) continue;
|
|
try {
|
|
fs.accessSync(`${letter}:\\`);
|
|
} catch {
|
|
return letter;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function createSubstMapping(targetDir: string): SubstMapping | null {
|
|
if (process.platform !== "win32" || !path.isAbsolute(targetDir)) return null;
|
|
const drive = findFreeSubstDrive();
|
|
if (!drive) return null;
|
|
const result = spawnSync("subst", [`${drive}:`, targetDir], { stdio: "pipe", timeout: 5000 });
|
|
if (result.status !== 0) {
|
|
logger.warn(`subst ${drive}: fehlgeschlagen: ${String(result.stderr || "").trim()}`);
|
|
return null;
|
|
}
|
|
activeSubstDrives.add(drive);
|
|
logger.info(`subst ${drive}: -> ${targetDir}`);
|
|
return { drive, original: targetDir };
|
|
}
|
|
|
|
function removeSubstMapping(mapping: SubstMapping): void {
|
|
spawnSync("subst", [`${mapping.drive}:`, "/d"], { stdio: "pipe", timeout: 5000 });
|
|
activeSubstDrives.delete(mapping.drive);
|
|
logger.info(`subst ${mapping.drive}: entfernt`);
|
|
}
|
|
|
|
export function cleanupStaleSubstDrives(): void {
|
|
if (process.platform !== "win32") return;
|
|
try {
|
|
const result = spawnSync("subst", [], { stdio: "pipe", timeout: 5000 });
|
|
const output = String(result.stdout || "");
|
|
for (const line of output.split("\n")) {
|
|
const match = line.match(/^([A-Z]):\\: => (.+)/i);
|
|
if (!match) continue;
|
|
const drive = match[1].toUpperCase();
|
|
const target = match[2].trim();
|
|
if (/\\rd-extract-|\\Real-Debrid-Downloader/i.test(target)) {
|
|
spawnSync("subst", [`${drive}:`, "/d"], { stdio: "pipe", timeout: 5000 });
|
|
logger.info(`Stale subst ${drive}: entfernt (${target})`);
|
|
}
|
|
}
|
|
} catch {
|
|
}
|
|
}
|
|
|
|
export async function detectArchiveSignature(filePath: string): Promise<ArchiveSignature> {
|
|
let fd: fs.promises.FileHandle | null = null;
|
|
try {
|
|
fd = await fs.promises.open(filePath, "r");
|
|
const buf = Buffer.alloc(8);
|
|
const { bytesRead } = await fd.read(buf, 0, 8, 0);
|
|
if (bytesRead < 3) return null;
|
|
const hex = buf.subarray(0, bytesRead).toString("hex");
|
|
for (const sig of ARCHIVE_SIGNATURES) {
|
|
if (hex.startsWith(sig.prefix)) return sig.type;
|
|
}
|
|
return null;
|
|
} catch {
|
|
return null;
|
|
} finally {
|
|
await fd?.close();
|
|
}
|
|
}
|
|
|
|
export function pathSetKey(filePath: string): string {
|
|
return process.platform === "win32" ? filePath.toLowerCase() : filePath;
|
|
}
|
|
|
|
function archiveNameKey(fileName: string): string {
|
|
return process.platform === "win32" ? String(fileName || "").toLowerCase() : String(fileName || "");
|
|
}
|
|
|
|
function stripDuplicateSuffixBeforeExtension(fileName: string): string {
|
|
return String(fileName || "").replace(/ \(\d+\)(?=\.[^.]+$)/, "");
|
|
}
|
|
|
|
function hasDuplicateSuffixBeforeExtension(fileName: string): boolean {
|
|
return stripDuplicateSuffixBeforeExtension(fileName) !== String(fileName || "");
|
|
}
|
|
|
|
function archiveDetectionName(fileName: string): string {
|
|
return stripDuplicateSuffixBeforeExtension(path.basename(String(fileName || "")));
|
|
}
|
|
|
|
function archiveCandidateIdentity(filePath: string): string {
|
|
const normalizedPath = path.join(path.dirname(filePath), archiveDetectionName(filePath));
|
|
return pathSetKey(normalizedPath);
|
|
}
|
|
|
|
function prefersArchiveCandidate(nextCandidate: string, currentCandidate: string): boolean {
|
|
const nextName = path.basename(nextCandidate);
|
|
const currentName = path.basename(currentCandidate);
|
|
const nextHasDuplicateSuffix = hasDuplicateSuffixBeforeExtension(nextName);
|
|
const currentHasDuplicateSuffix = hasDuplicateSuffixBeforeExtension(currentName);
|
|
if (nextHasDuplicateSuffix !== currentHasDuplicateSuffix) {
|
|
return !nextHasDuplicateSuffix;
|
|
}
|
|
return ARCHIVE_SORT_COLLATOR.compare(nextName, currentName) < 0;
|
|
}
|
|
|
|
function archiveSortKey(filePath: string): string {
|
|
const fileName = archiveDetectionName(filePath).toLowerCase();
|
|
return fileName
|
|
.replace(/\.part0*1\.rar$/i, "")
|
|
.replace(/\.zip\.\d{3}$/i, "")
|
|
.replace(/\.7z\.\d{3}$/i, "")
|
|
.replace(/\.\d{3}$/i, "")
|
|
.replace(/\.(?:tar\.(?:gz|bz2|xz)|tgz|tbz2|txz)$/i, "")
|
|
.replace(/\.rar$/i, "")
|
|
.replace(/\.zip$/i, "")
|
|
.replace(/\.7z$/i, "")
|
|
.replace(/[._\-\s]+$/g, "");
|
|
}
|
|
|
|
function archiveTypeRank(filePath: string): number {
|
|
const fileName = archiveDetectionName(filePath).toLowerCase();
|
|
if (/\.part0*1\.rar$/i.test(fileName)) {
|
|
return 0;
|
|
}
|
|
if (/\.rar$/i.test(fileName)) {
|
|
return 1;
|
|
}
|
|
if (/\.zip(?:\.\d{3})?$/i.test(fileName)) {
|
|
return 2;
|
|
}
|
|
if (/\.7z(?:\.\d{3})?$/i.test(fileName)) {
|
|
return 3;
|
|
}
|
|
if (/\.(?:tar\.(?:gz|bz2|xz)|tgz|tbz2|txz)$/i.test(fileName)) {
|
|
return 4;
|
|
}
|
|
if (/\.\d{3}$/i.test(fileName)) {
|
|
return 5;
|
|
}
|
|
return 9;
|
|
}
|
|
|
|
export async function findArchiveCandidates(packageDir: string): Promise<string[]> {
|
|
if (!packageDir) {
|
|
return [];
|
|
}
|
|
try {
|
|
await fs.promises.access(packageDir);
|
|
} catch {
|
|
return [];
|
|
}
|
|
|
|
let files: string[] = [];
|
|
try {
|
|
files = (await fs.promises.readdir(packageDir, { withFileTypes: true }))
|
|
.filter((entry) => entry.isFile())
|
|
.map((entry) => path.join(packageDir, entry.name));
|
|
} catch {
|
|
return [];
|
|
}
|
|
|
|
const fileNamesLower = new Set(files.map((filePath) => archiveDetectionName(filePath).toLowerCase()));
|
|
const multipartRar = files.filter((filePath) => /\.part0*1\.rar$/i.test(archiveDetectionName(filePath)));
|
|
const singleRar = files.filter((filePath) => {
|
|
const fileName = archiveDetectionName(filePath);
|
|
return /\.rar$/i.test(fileName) && !/\.part\d+\.rar$/i.test(fileName);
|
|
});
|
|
const zipSplit = files.filter((filePath) => /\.zip\.001$/i.test(archiveDetectionName(filePath)));
|
|
const zip = files.filter((filePath) => {
|
|
const fileName = archiveDetectionName(filePath);
|
|
if (!/\.zip$/i.test(fileName)) {
|
|
return false;
|
|
}
|
|
return !fileNamesLower.has(`${fileName}.001`.toLowerCase());
|
|
});
|
|
const sevenSplit = files.filter((filePath) => /\.7z\.001$/i.test(archiveDetectionName(filePath)));
|
|
const seven = files.filter((filePath) => {
|
|
const fileName = archiveDetectionName(filePath);
|
|
if (!/\.7z$/i.test(fileName)) {
|
|
return false;
|
|
}
|
|
return !fileNamesLower.has(`${fileName}.001`.toLowerCase());
|
|
});
|
|
const tarCompressed = files.filter((filePath) => /\.(?:tar\.(?:gz|bz2|xz)|tgz|tbz2|txz)$/i.test(filePath));
|
|
const genericSplit = files.filter((filePath) => {
|
|
const fileName = archiveDetectionName(filePath).toLowerCase();
|
|
if (!/\.001$/.test(fileName)) return false;
|
|
if (/\.zip\.001$/.test(fileName) || /\.7z\.001$/.test(fileName)) return false;
|
|
return true;
|
|
});
|
|
|
|
const unique: string[] = [];
|
|
const seen = new Map<string, number>();
|
|
for (const candidate of [...multipartRar, ...singleRar, ...zipSplit, ...zip, ...sevenSplit, ...seven, ...tarCompressed, ...genericSplit]) {
|
|
const key = archiveCandidateIdentity(candidate);
|
|
const existingIndex = seen.get(key);
|
|
if (existingIndex !== undefined) {
|
|
if (prefersArchiveCandidate(candidate, unique[existingIndex])) {
|
|
unique[existingIndex] = candidate;
|
|
}
|
|
continue;
|
|
}
|
|
seen.set(key, unique.length);
|
|
unique.push(candidate);
|
|
}
|
|
|
|
unique.sort((left, right) => {
|
|
const keyCmp = ARCHIVE_SORT_COLLATOR.compare(archiveSortKey(left), archiveSortKey(right));
|
|
if (keyCmp !== 0) {
|
|
return keyCmp;
|
|
}
|
|
const rankCmp = archiveTypeRank(left) - archiveTypeRank(right);
|
|
if (rankCmp !== 0) {
|
|
return rankCmp;
|
|
}
|
|
return ARCHIVE_SORT_COLLATOR.compare(path.basename(left), path.basename(right));
|
|
});
|
|
|
|
return unique;
|
|
}
|
|
|
|
function escapeRegex(value: string): string {
|
|
return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
|
}
|
|
|
|
export function collectArchiveCleanupTargets(sourceArchivePath: string, directoryFiles?: string[]): string[] {
|
|
const targets = new Set<string>([sourceArchivePath]);
|
|
const dir = path.dirname(sourceArchivePath);
|
|
const fileName = path.basename(sourceArchivePath);
|
|
|
|
let filesInDir: string[] = directoryFiles ?? [];
|
|
if (!directoryFiles) {
|
|
try {
|
|
filesInDir = fs.readdirSync(dir, { withFileTypes: true })
|
|
.filter((entry) => entry.isFile())
|
|
.map((entry) => entry.name);
|
|
} catch {
|
|
return Array.from(targets);
|
|
}
|
|
}
|
|
|
|
const addMatching = (pattern: RegExp): void => {
|
|
for (const candidate of filesInDir) {
|
|
if (pattern.test(candidate)) {
|
|
targets.add(path.join(dir, candidate));
|
|
}
|
|
}
|
|
};
|
|
|
|
const COMPANION_EXTS_RE = /\.(?:sfv|nfo|nzb|md5|sha1|sha256|crc|srr)$/i;
|
|
const addCompanions = (stemRe: string): void => {
|
|
for (const candidate of filesInDir) {
|
|
if (!COMPANION_EXTS_RE.test(candidate)) continue;
|
|
const candidateStem = candidate.replace(/\.[^.]+$/, "");
|
|
if (new RegExp(`^${stemRe}$`, "i").test(candidateStem)) {
|
|
targets.add(path.join(dir, candidate));
|
|
}
|
|
}
|
|
};
|
|
|
|
const multipartRar = fileName.match(/^(.*)\.part\d+\.rar$/i);
|
|
if (multipartRar) {
|
|
const prefix = escapeRegex(multipartRar[1]);
|
|
addMatching(new RegExp(`^${prefix}\\.part\\d+\\.rar$`, "i"));
|
|
addMatching(new RegExp(`^${prefix}\\.part\\d+\\.rev$`, "i"));
|
|
addMatching(new RegExp(`^${prefix}\\.rev$`, "i"));
|
|
addCompanions(prefix);
|
|
return Array.from(targets);
|
|
}
|
|
|
|
if (/\.rar$/i.test(fileName)) {
|
|
const stem = escapeRegex(fileName.replace(/\.rar$/i, ""));
|
|
addMatching(new RegExp(`^${stem}\\.rar$`, "i"));
|
|
addMatching(new RegExp(`^${stem}\\.r\\d{2,3}$`, "i"));
|
|
addMatching(new RegExp(`^${stem}\\.rev$`, "i"));
|
|
addCompanions(stem);
|
|
return Array.from(targets);
|
|
}
|
|
|
|
if (/\.zip$/i.test(fileName)) {
|
|
const stem = escapeRegex(fileName.replace(/\.zip$/i, ""));
|
|
addMatching(new RegExp(`^${stem}\\.zip$`, "i"));
|
|
addMatching(new RegExp(`^${stem}\\.z\\d{2,3}$`, "i"));
|
|
addCompanions(stem);
|
|
return Array.from(targets);
|
|
}
|
|
|
|
const splitZip = fileName.match(/^(.*)\.zip\.\d{3}$/i);
|
|
if (splitZip) {
|
|
const stem = escapeRegex(splitZip[1]);
|
|
addMatching(new RegExp(`^${stem}\\.zip$`, "i"));
|
|
addMatching(new RegExp(`^${stem}\\.zip\\.\\d{3}$`, "i"));
|
|
addCompanions(stem);
|
|
return Array.from(targets);
|
|
}
|
|
|
|
if (/\.7z$/i.test(fileName)) {
|
|
const stem = escapeRegex(fileName.replace(/\.7z$/i, ""));
|
|
addMatching(new RegExp(`^${stem}\\.7z$`, "i"));
|
|
addMatching(new RegExp(`^${stem}\\.7z\\.\\d{3}$`, "i"));
|
|
addCompanions(stem);
|
|
return Array.from(targets);
|
|
}
|
|
|
|
const splitSeven = fileName.match(/^(.*)\.7z\.\d{3}$/i);
|
|
if (splitSeven) {
|
|
const stem = escapeRegex(splitSeven[1]);
|
|
addMatching(new RegExp(`^${stem}\\.7z$`, "i"));
|
|
addMatching(new RegExp(`^${stem}\\.7z\\.\\d{3}$`, "i"));
|
|
addCompanions(stem);
|
|
return Array.from(targets);
|
|
}
|
|
|
|
if (/\.(?:tar\.(?:gz|bz2|xz)|tgz|tbz2|txz)$/i.test(fileName)) {
|
|
return Array.from(targets);
|
|
}
|
|
|
|
const genericSplit = fileName.match(/^(.*)\.(\d{3})$/i);
|
|
if (genericSplit) {
|
|
const stem = escapeRegex(genericSplit[1]);
|
|
addMatching(new RegExp(`^${stem}\\.\\d{3}$`, "i"));
|
|
return Array.from(targets);
|
|
}
|
|
|
|
return Array.from(targets);
|
|
}
|
|
|
|
export async function cleanupArchives(
|
|
sourceFiles: string[],
|
|
cleanupMode: CleanupMode,
|
|
options: { shouldAbort?: () => boolean } = {}
|
|
): Promise<number> {
|
|
if (cleanupMode === "none") {
|
|
return 0;
|
|
}
|
|
|
|
const targets = new Set<string>();
|
|
const dirFilesCache = new Map<string, string[]>();
|
|
for (const sourceFile of sourceFiles) {
|
|
if (options.shouldAbort?.()) {
|
|
return 0;
|
|
}
|
|
const dir = path.dirname(sourceFile);
|
|
let filesInDir = dirFilesCache.get(dir);
|
|
if (!filesInDir) {
|
|
try {
|
|
filesInDir = (await fs.promises.readdir(dir, { withFileTypes: true }))
|
|
.filter((entry) => entry.isFile())
|
|
.map((entry) => entry.name);
|
|
} catch {
|
|
filesInDir = [];
|
|
}
|
|
dirFilesCache.set(dir, filesInDir);
|
|
}
|
|
|
|
for (const target of collectArchiveCleanupTargets(sourceFile, filesInDir)) {
|
|
targets.add(target);
|
|
}
|
|
}
|
|
|
|
let removed = 0;
|
|
|
|
const moveToTrashLike = async (filePath: string): Promise<boolean> => {
|
|
try {
|
|
const parsed = path.parse(filePath);
|
|
const trashDir = path.join(parsed.dir, ".rd-trash");
|
|
await fs.promises.mkdir(trashDir, { recursive: true });
|
|
let index = 0;
|
|
while (index <= 10000) {
|
|
const suffix = index === 0 ? "" : `-${index}`;
|
|
const candidate = path.join(trashDir, `${parsed.base}.${Date.now()}${suffix}`);
|
|
const candidateExists = await fs.promises.access(candidate).then(() => true, () => false);
|
|
if (!candidateExists) {
|
|
await fs.promises.rename(filePath, candidate);
|
|
return true;
|
|
}
|
|
index += 1;
|
|
}
|
|
} catch {
|
|
}
|
|
return false;
|
|
};
|
|
|
|
for (const filePath of targets) {
|
|
if (options.shouldAbort?.()) {
|
|
return removed;
|
|
}
|
|
try {
|
|
const fileExists = await fs.promises.access(filePath).then(() => true, () => false);
|
|
if (!fileExists) {
|
|
continue;
|
|
}
|
|
if (cleanupMode === "trash") {
|
|
if (await moveToTrashLike(filePath)) {
|
|
removed += 1;
|
|
}
|
|
continue;
|
|
}
|
|
await fs.promises.rm(filePath, { force: true });
|
|
removed += 1;
|
|
} catch {
|
|
}
|
|
}
|
|
return removed;
|
|
}
|
|
|
|
export async function hasAnyFilesRecursive(rootDir: string): Promise<boolean> {
|
|
const rootExists = await fs.promises.access(rootDir).then(() => true, () => false);
|
|
if (!rootExists) {
|
|
return false;
|
|
}
|
|
const deadline = Date.now() + 220;
|
|
let inspectedDirs = 0;
|
|
const stack = [rootDir];
|
|
while (stack.length > 0) {
|
|
inspectedDirs += 1;
|
|
if (inspectedDirs > 8000 || Date.now() > deadline) {
|
|
return hasAnyEntries(rootDir);
|
|
}
|
|
const current = stack.pop() as string;
|
|
let entries: fs.Dirent[] = [];
|
|
try {
|
|
entries = await fs.promises.readdir(current, { withFileTypes: true });
|
|
} catch {
|
|
continue;
|
|
}
|
|
|
|
for (const entry of entries) {
|
|
if (entry.isFile()) {
|
|
return true;
|
|
}
|
|
if (entry.isDirectory()) {
|
|
stack.push(path.join(current, entry.name));
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
async function hasAnyEntries(rootDir: string): Promise<boolean> {
|
|
if (!rootDir) {
|
|
return false;
|
|
}
|
|
const rootExists = await fs.promises.access(rootDir).then(() => true, () => false);
|
|
if (!rootExists) {
|
|
return false;
|
|
}
|
|
try {
|
|
return (await fs.promises.readdir(rootDir)).length > 0;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
export async function removeEmptyDirectoryTree(rootDir: string): Promise<number> {
|
|
const rootExists = await fs.promises.access(rootDir).then(() => true, () => false);
|
|
if (!rootExists) {
|
|
return 0;
|
|
}
|
|
|
|
const dirs = [rootDir];
|
|
const stack = [rootDir];
|
|
while (stack.length > 0) {
|
|
const current = stack.pop() as string;
|
|
let entries: fs.Dirent[] = [];
|
|
try {
|
|
entries = await fs.promises.readdir(current, { withFileTypes: true });
|
|
} catch {
|
|
continue;
|
|
}
|
|
for (const entry of entries) {
|
|
if (entry.isDirectory()) {
|
|
const full = path.join(current, entry.name);
|
|
dirs.push(full);
|
|
stack.push(full);
|
|
}
|
|
}
|
|
}
|
|
|
|
dirs.sort((a, b) => b.length - a.length);
|
|
let removed = 0;
|
|
for (const dirPath of dirs) {
|
|
try {
|
|
const entries = await fs.promises.readdir(dirPath);
|
|
if (entries.length === 0) {
|
|
await fs.promises.rmdir(dirPath);
|
|
removed += 1;
|
|
}
|
|
} catch {
|
|
}
|
|
}
|
|
return removed;
|
|
}
|
|
|
|
function packagePasswordCacheKey(packageDir: string, packageId?: string): string {
|
|
const normalizedPackageId = String(packageId || "").trim();
|
|
if (normalizedPackageId) {
|
|
return `pkg:${normalizedPackageId}`;
|
|
}
|
|
return `dir:${pathSetKey(path.resolve(packageDir))}`;
|
|
}
|
|
|
|
function packagePasswordCacheLabel(packageDir: string, packageId?: string): string {
|
|
const normalizedPackageId = String(packageId || "").trim();
|
|
if (normalizedPackageId) {
|
|
return `packageId=${normalizedPackageId.slice(0, 8)}`;
|
|
}
|
|
return `packageDir=${path.basename(path.resolve(packageDir))}`;
|
|
}
|
|
|
|
function readCachedPackagePassword(cacheKey: string): string {
|
|
const cached = packageLearnedPasswords.get(cacheKey);
|
|
if (!cached) {
|
|
return "";
|
|
}
|
|
packageLearnedPasswords.delete(cacheKey);
|
|
packageLearnedPasswords.set(cacheKey, cached);
|
|
return cached;
|
|
}
|
|
|
|
function writeCachedPackagePassword(cacheKey: string, password: string): void {
|
|
const normalized = String(password || "").trim();
|
|
if (!normalized) {
|
|
return;
|
|
}
|
|
if (packageLearnedPasswords.has(cacheKey)) {
|
|
packageLearnedPasswords.delete(cacheKey);
|
|
}
|
|
packageLearnedPasswords.set(cacheKey, normalized);
|
|
if (packageLearnedPasswords.size > PACKAGE_PASSWORD_CACHE_LIMIT) {
|
|
const oldestKey = packageLearnedPasswords.keys().next().value as string | undefined;
|
|
if (oldestKey) {
|
|
packageLearnedPasswords.delete(oldestKey);
|
|
}
|
|
}
|
|
}
|
|
|
|
function clearCachedPackagePassword(cacheKey: string): void {
|
|
packageLearnedPasswords.delete(cacheKey);
|
|
}
|
|
|
|
export function resetExtractorCachesForPasswordChange(): { learnedCleared: number; daemonRestarted: boolean } {
|
|
const learnedCleared = packageLearnedPasswords.size;
|
|
packageLearnedPasswords.clear();
|
|
let daemonRestarted = false;
|
|
if (daemonProcess && !daemonBusy) {
|
|
shutdownDaemon();
|
|
daemonRestarted = true;
|
|
}
|
|
return { learnedCleared, daemonRestarted };
|
|
}
|
|
|
|
export function archiveFilenamePasswords(archiveName: string): string[] {
|
|
const name = String(archiveName || "");
|
|
if (!name) return [];
|
|
const stem = name
|
|
.replace(/\.part\d+\.rar$/i, "")
|
|
.replace(/\.zip\.\d{3}$/i, "")
|
|
.replace(/\.7z\.\d{3}$/i, "")
|
|
.replace(/\.\d{3}$/i, "")
|
|
.replace(/\.(?:tar\.(?:gz|bz2|xz)|tgz|tbz2|txz)$/i, "")
|
|
.replace(/\.(rar|zip|7z|tar|gz|bz2|xz)$/i, "");
|
|
if (!stem) return [];
|
|
const candidates = [stem];
|
|
const withSpaces = stem.replace(/[._]/g, " ");
|
|
if (withSpaces !== stem) candidates.push(withSpaces);
|
|
return candidates;
|
|
}
|
|
|
|
function archivePasswords(listInput: string): string[] {
|
|
const custom = String(listInput || "")
|
|
.split(/\r?\n/g)
|
|
.map((part) => part.trim())
|
|
.filter(Boolean);
|
|
|
|
const fromEnv = String(process.env.RD_ARCHIVE_PASSWORDS || "")
|
|
.split(/[;,\n]/g)
|
|
.map((part) => part.trim())
|
|
.filter(Boolean);
|
|
|
|
return Array.from(new Set(["", ...custom, ...fromEnv, ...DEFAULT_ARCHIVE_PASSWORDS]));
|
|
}
|
|
|
|
function prioritizePassword(passwords: string[], successful: string): string[] {
|
|
const target = String(successful || "");
|
|
if (!target || passwords.length <= 1) {
|
|
return passwords;
|
|
}
|
|
const index = passwords.findIndex((candidate) => candidate === target);
|
|
if (index === 0) {
|
|
return passwords;
|
|
}
|
|
if (index < 0) {
|
|
return [target, ...passwords.filter((candidate) => candidate !== target)];
|
|
}
|
|
const next = [...passwords];
|
|
const [value] = next.splice(index, 1);
|
|
next.unshift(value);
|
|
return next;
|
|
}
|
|
|
|
export function cleanErrorText(text: string): string {
|
|
const normalized = String(text || "").replace(/\s+/g, " ").trim();
|
|
if (normalized.length <= 500) {
|
|
return normalized;
|
|
}
|
|
const head = normalized.slice(0, 240).trimEnd();
|
|
const tail = normalized.slice(-240).trimStart();
|
|
return `${head} ... ${tail}`;
|
|
}
|
|
|
|
function appendLimited(base: string, chunk: string, maxLen = MAX_EXTRACT_OUTPUT_BUFFER): string {
|
|
const next = `${base}${chunk}`;
|
|
if (next.length <= maxLen) {
|
|
return next;
|
|
}
|
|
return next.slice(next.length - maxLen);
|
|
}
|
|
|
|
function withExtractionErrorHints(
|
|
error: unknown,
|
|
hints: {
|
|
suggestRedownload?: boolean;
|
|
jvmFailureReason?: string;
|
|
legacyBestPercent?: number;
|
|
legacyExtractor?: string;
|
|
}
|
|
): Error {
|
|
const base = error instanceof Error ? error : new Error(String(error || "Entpacken fehlgeschlagen"));
|
|
const enhanced = base as ExtractionErrorWithHints;
|
|
if (hints.suggestRedownload) {
|
|
enhanced.suggestRedownload = true;
|
|
}
|
|
if (hints.jvmFailureReason) {
|
|
enhanced.jvmFailureReason = hints.jvmFailureReason;
|
|
}
|
|
if (Number.isFinite(hints.legacyBestPercent)) {
|
|
enhanced.legacyBestPercent = Math.max(Number(enhanced.legacyBestPercent || 0), Number(hints.legacyBestPercent || 0));
|
|
}
|
|
if (hints.legacyExtractor) {
|
|
enhanced.legacyExtractor = hints.legacyExtractor;
|
|
}
|
|
return enhanced;
|
|
}
|
|
|
|
export function classifyExtractionError(errorText: string): ExtractErrorCategory {
|
|
const text = String(errorText || "").toLowerCase();
|
|
if (text.includes("aborted:extract") || text.includes("extract_aborted")) return "aborted";
|
|
if (text.includes("timeout")) return "timeout";
|
|
if (text.includes("crc failed") || text.includes("checksum error") || text.includes("crc error")) return "crc_error";
|
|
if (text.includes("wrong password") || text.includes("falsches passwort") || text.includes("incorrect password")) return "wrong_password";
|
|
if (text.includes("missing volume") || text.includes("next volume") || text.includes("unexpected end of archive") || text.includes("missing parts")) return "missing_parts";
|
|
if (text.includes("nicht gefunden") || text.includes("not found") || text.includes("no extractor")) return "no_extractor";
|
|
if (text.includes("kein rar-archiv") || text.includes("not a rar archive") || text.includes("unsupported") || text.includes("unsupportedmethod")) return "unsupported_format";
|
|
if (text.includes("disk full") || text.includes("speicherplatz") || text.includes("no space left") || text.includes("not enough space")) return "disk_full";
|
|
return "unknown";
|
|
}
|
|
|
|
export function shouldSerialRetryParallelFailures(
|
|
extractedCount: number,
|
|
failedCategories: ExtractErrorCategory[]
|
|
): boolean {
|
|
if (failedCategories.length === 0) {
|
|
return false;
|
|
}
|
|
if (extractedCount > 0) {
|
|
return true;
|
|
}
|
|
return failedCategories.every((category) =>
|
|
category === "crc_error"
|
|
|| category === "wrong_password"
|
|
|| category === "unknown"
|
|
);
|
|
}
|
|
|
|
export function shouldFallbackLegacyRarToJvm(
|
|
archivePath: string,
|
|
configuredMode: ExtractBackendMode,
|
|
backendMode: ExtractBackendMode,
|
|
errorText: string,
|
|
bestPercent = 0,
|
|
platform = process.platform
|
|
): boolean {
|
|
if (configuredMode !== "auto" || backendMode !== "legacy") {
|
|
return false;
|
|
}
|
|
if (String(platform || "").toLowerCase() !== "win32") {
|
|
return false;
|
|
}
|
|
if (!isRarArchivePath(archivePath)) {
|
|
return false;
|
|
}
|
|
|
|
const category = classifyExtractionError(errorText);
|
|
if (category === "aborted" || category === "timeout" || category === "no_extractor" || category === "missing_parts" || category === "disk_full") {
|
|
return false;
|
|
}
|
|
|
|
const text = String(errorText || "").toLowerCase();
|
|
if (text.includes("cannot create")) {
|
|
return false;
|
|
}
|
|
|
|
return bestPercent > 0 || category === "unknown";
|
|
}
|
|
|
|
function isExtractAbortError(errorText: string): boolean {
|
|
const text = String(errorText || "").toLowerCase();
|
|
return text.includes("aborted:extract") || text.includes("extract_aborted") || text.includes("noextractor:skipped");
|
|
}
|
|
|
|
function isNoExtractorError(errorText: string): boolean {
|
|
return String(errorText || "").toLowerCase().includes("nicht gefunden");
|
|
}
|
|
|
|
function isUnsupportedArchiveFormatError(errorText: string): boolean {
|
|
const text = String(errorText || "").toLowerCase();
|
|
return text.includes("kein rar-archiv")
|
|
|| text.includes("not a rar archive")
|
|
|| text.includes("is not a rar archive");
|
|
}
|
|
|
|
function isUnsupportedExtractorSwitchError(errorText: string): boolean {
|
|
const text = String(errorText || "").toLowerCase();
|
|
return text.includes("unknown switch")
|
|
|| text.includes("unknown option")
|
|
|| text.includes("invalid switch")
|
|
|| text.includes("unsupported option")
|
|
|| text.includes("unbekannter schalter")
|
|
|| text.includes("falscher parameter");
|
|
}
|
|
|
|
function isJvmRuntimeMissingError(errorText: string): boolean {
|
|
const text = String(errorText || "").toLowerCase();
|
|
return text.includes("could not find or load main class")
|
|
|| text.includes("classnotfoundexception")
|
|
|| text.includes("noclassdeffounderror")
|
|
|| text.includes("unsatisfiedlinkerror")
|
|
|| text.includes("enoent");
|
|
}
|
|
|
|
export function resolveExtractorBackendMode(
|
|
rawValue?: string | null,
|
|
isVitestEnv = Boolean(process.env.VITEST)
|
|
): ExtractBackendMode {
|
|
const defaultMode: ExtractBackendMode = isVitestEnv ? "legacy" : "auto";
|
|
const raw = String(rawValue ?? defaultMode).trim().toLowerCase();
|
|
if (raw === "legacy") {
|
|
return "legacy";
|
|
}
|
|
if (raw === "jvm" || raw === "jbind" || raw === "7zjbinding") {
|
|
return "jvm";
|
|
}
|
|
return "auto";
|
|
}
|
|
|
|
export function resolveExtractorBackendModeForArchive(
|
|
archivePath: string,
|
|
rawValue?: string | null,
|
|
isVitestEnv = Boolean(process.env.VITEST),
|
|
platform = process.platform
|
|
): ExtractBackendMode {
|
|
const requestedMode = resolveExtractorBackendMode(rawValue, isVitestEnv);
|
|
if (requestedMode !== "auto") {
|
|
return requestedMode;
|
|
}
|
|
if (String(platform || "").toLowerCase() === "win32" && isRarArchivePath(archivePath)) {
|
|
return "legacy";
|
|
}
|
|
return requestedMode;
|
|
}
|
|
|
|
function extractorBackendMode(): ExtractBackendMode {
|
|
return resolveExtractorBackendMode(process.env.RD_EXTRACT_BACKEND);
|
|
}
|
|
|
|
function extractorBackendModeForArchive(archivePath: string): ExtractBackendMode {
|
|
return resolveExtractorBackendModeForArchive(archivePath, process.env.RD_EXTRACT_BACKEND);
|
|
}
|
|
|
|
function isRarArchivePath(filePath: string): boolean {
|
|
return /\.(?:rar|r\d{2,3})$/i.test(String(filePath || ""));
|
|
}
|
|
|
|
function is7zCommand(command: string): boolean {
|
|
const lower = command.toLowerCase();
|
|
return lower.includes("7z") && !lower.includes("unrar") && !lower.includes("winrar");
|
|
}
|
|
|
|
function isRarNativeCommand(command: string): boolean {
|
|
const base = path.basename(String(command || "")).toLowerCase();
|
|
return base === "unrar.exe"
|
|
|| base === "unrar"
|
|
|| base === "winrar.exe"
|
|
|| base === "rar.exe"
|
|
|| base === "rar";
|
|
}
|
|
|
|
function extractorCommandKind(command: string): ExtractorCommandKind {
|
|
if (isRarNativeCommand(command)) {
|
|
return "rar_native";
|
|
}
|
|
if (is7zCommand(command)) {
|
|
return "seven_zip";
|
|
}
|
|
return "other";
|
|
}
|
|
|
|
function isAbsoluteCommand(command: string): boolean {
|
|
return path.isAbsolute(command)
|
|
|| command.includes("\\")
|
|
|| command.includes("/");
|
|
}
|
|
|
|
function cachedExtractorFitsArchive(command: string, archivePath: string): boolean {
|
|
if (!archivePath) {
|
|
return true;
|
|
}
|
|
const kind = extractorCommandKind(command);
|
|
if (isRarArchivePath(archivePath)) {
|
|
return kind === "rar_native";
|
|
}
|
|
return kind === "seven_zip";
|
|
}
|
|
|
|
export function orderExtractorCandidatesForArchive(
|
|
candidates: string[],
|
|
archivePath: string,
|
|
preferredCommand = ""
|
|
): string[] {
|
|
const unique = Array.from(new Set(candidates.filter(Boolean)));
|
|
const preferRarNative = isRarArchivePath(archivePath);
|
|
const rank = (command: string): number => {
|
|
const kind = extractorCommandKind(command);
|
|
if (preferRarNative) {
|
|
if (kind === "rar_native") return 0;
|
|
if (kind === "seven_zip") return 1;
|
|
return 2;
|
|
}
|
|
if (kind === "seven_zip") return 0;
|
|
if (kind === "rar_native") return 1;
|
|
return 2;
|
|
};
|
|
|
|
return unique
|
|
.map((command, index) => ({ command, index }))
|
|
.sort((left, right) => {
|
|
const rankDiff = rank(left.command) - rank(right.command);
|
|
if (rankDiff !== 0) {
|
|
return rankDiff;
|
|
}
|
|
const leftPreferred = preferredCommand && left.command === preferredCommand;
|
|
const rightPreferred = preferredCommand && right.command === preferredCommand;
|
|
if (leftPreferred !== rightPreferred) {
|
|
return leftPreferred ? -1 : 1;
|
|
}
|
|
return left.index - right.index;
|
|
})
|
|
.map((entry) => entry.command);
|
|
}
|
|
|
|
function nativeExtractorCandidates(archivePath = ""): string[] {
|
|
const programFiles = process.env.ProgramFiles || "C:\\Program Files";
|
|
const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)";
|
|
const localAppData = process.env.LOCALAPPDATA || "";
|
|
|
|
const sevenZipInstalled = [
|
|
process.env.RD_7Z_BIN || "",
|
|
path.join(programFiles, "7-Zip", "7z.exe"),
|
|
path.join(programFilesX86, "7-Zip", "7z.exe")
|
|
];
|
|
if (localAppData) {
|
|
sevenZipInstalled.push(path.join(localAppData, "Programs", "7-Zip", "7z.exe"));
|
|
}
|
|
|
|
const winRarInstalled = [
|
|
path.join(programFiles, "WinRAR", "Rar.exe"),
|
|
path.join(programFilesX86, "WinRAR", "Rar.exe"),
|
|
path.join(programFiles, "WinRAR", "UnRAR.exe"),
|
|
path.join(programFilesX86, "WinRAR", "UnRAR.exe")
|
|
];
|
|
|
|
if (localAppData) {
|
|
winRarInstalled.push(path.join(localAppData, "Programs", "WinRAR", "Rar.exe"));
|
|
winRarInstalled.push(path.join(localAppData, "Programs", "WinRAR", "UnRAR.exe"));
|
|
}
|
|
|
|
const ordered = resolvedExtractorCommand
|
|
? [
|
|
resolvedExtractorCommand,
|
|
...sevenZipInstalled,
|
|
"7z.exe",
|
|
"7z",
|
|
"7za.exe",
|
|
"7za",
|
|
...winRarInstalled,
|
|
"Rar.exe",
|
|
"rar",
|
|
"UnRAR.exe",
|
|
"unrar"
|
|
]
|
|
: [
|
|
...sevenZipInstalled,
|
|
"7z.exe",
|
|
"7z",
|
|
"7za.exe",
|
|
"7za",
|
|
...winRarInstalled,
|
|
"Rar.exe",
|
|
"rar",
|
|
"UnRAR.exe",
|
|
"unrar"
|
|
];
|
|
return orderExtractorCandidatesForArchive(ordered, archivePath, resolvedExtractorCommand || "");
|
|
}
|
|
|
|
function extractorProbeArgs(command: string): string[] {
|
|
return isRarNativeCommand(command) ? ["-?"] : ["?"];
|
|
}
|
|
|
|
async function resolveExtractorCommandInternal(archivePath = ""): Promise<string> {
|
|
if (resolvedExtractorCommand) {
|
|
return resolvedExtractorCommand;
|
|
}
|
|
if (resolveFailureReason) {
|
|
const age = Date.now() - resolveFailureAt;
|
|
if (age < EXTRACTOR_RETRY_AFTER_MS) {
|
|
throw new Error(resolveFailureReason);
|
|
}
|
|
resolveFailureReason = "";
|
|
resolveFailureAt = 0;
|
|
}
|
|
|
|
const candidates = nativeExtractorCandidates(archivePath);
|
|
for (const command of candidates) {
|
|
if (isAbsoluteCommand(command) && !fs.existsSync(command)) {
|
|
continue;
|
|
}
|
|
const probeArgs = extractorProbeArgs(command);
|
|
const probe = await runExtractCommand(command, probeArgs, undefined, undefined, EXTRACTOR_PROBE_TIMEOUT_MS);
|
|
if (probe.ok || (!probe.missingCommand && !probe.timedOut)) {
|
|
resolvedExtractorCommand = command;
|
|
resolveFailureReason = "";
|
|
resolveFailureAt = 0;
|
|
logger.info(`Entpacker erkannt: ${command}`);
|
|
return command;
|
|
}
|
|
}
|
|
|
|
resolveFailureReason = NO_EXTRACTOR_MESSAGE;
|
|
resolveFailureAt = Date.now();
|
|
throw new Error(resolveFailureReason);
|
|
}
|
|
|
|
async function resolveExtractorCommand(archivePath = ""): Promise<string> {
|
|
if (resolvedExtractorCommand && cachedExtractorFitsArchive(resolvedExtractorCommand, archivePath)) {
|
|
return resolvedExtractorCommand;
|
|
}
|
|
if (resolveExtractorCommandInFlight) {
|
|
return resolveExtractorCommandInFlight;
|
|
}
|
|
|
|
const pending = resolveExtractorCommandInternal(archivePath);
|
|
resolveExtractorCommandInFlight = pending;
|
|
try {
|
|
return await pending;
|
|
} finally {
|
|
if (resolveExtractorCommandInFlight === pending) {
|
|
resolveExtractorCommandInFlight = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
async function findAlternativeExtractor(currentCommand: string, archivePath = ""): Promise<string | null> {
|
|
const candidates = nativeExtractorCandidates(archivePath);
|
|
const currentKind = extractorCommandKind(currentCommand);
|
|
const preferredKinds: ExtractorCommandKind[] = currentKind === "seven_zip"
|
|
? ["rar_native"]
|
|
: isRarArchivePath(archivePath)
|
|
? ["rar_native", "seven_zip"]
|
|
: ["seven_zip", "rar_native"];
|
|
for (const kind of preferredKinds) {
|
|
for (const candidate of candidates) {
|
|
if (candidate === currentCommand) continue;
|
|
if (extractorCommandKind(candidate) !== kind) continue;
|
|
if (isAbsoluteCommand(candidate) && !fs.existsSync(candidate)) continue;
|
|
const probe = await runExtractCommand(candidate, extractorProbeArgs(candidate), undefined, undefined, EXTRACTOR_PROBE_TIMEOUT_MS);
|
|
if (probe.ok || (!probe.missingCommand && !probe.timedOut)) {
|
|
return candidate;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function jvmMaxHeapArg(): string {
|
|
const totalGb = os.totalmem() / (1024 ** 3);
|
|
const heapGb = Math.max(1, Math.min(Math.floor(totalGb - 4), 16));
|
|
return `-Xmx${heapGb}g`;
|
|
}
|
|
|
|
function shouldUseExtractorPerformanceFlags(): boolean {
|
|
const raw = String(process.env.RD_EXTRACT_PERF_FLAGS || "").trim().toLowerCase();
|
|
return raw !== "0" && raw !== "false" && raw !== "off" && raw !== "no";
|
|
}
|
|
|
|
function extractCpuBudgetFromPriority(priority?: string): number {
|
|
switch (priority) {
|
|
case "low": return 25;
|
|
case "middle": return 50;
|
|
default: return 80;
|
|
}
|
|
}
|
|
|
|
function extractOsPriority(priority?: string): number {
|
|
switch (priority) {
|
|
case "high": return os.constants.priority.PRIORITY_NORMAL;
|
|
default: return os.constants.priority.PRIORITY_BELOW_NORMAL;
|
|
}
|
|
}
|
|
|
|
function extractCpuBudgetPercent(priority?: string): number {
|
|
const envValue = Number(process.env.RD_EXTRACT_CPU_BUDGET_PERCENT ?? NaN);
|
|
if (Number.isFinite(envValue) && envValue >= 40 && envValue <= 95) {
|
|
return Math.floor(envValue);
|
|
}
|
|
return extractCpuBudgetFromPriority(priority);
|
|
}
|
|
|
|
function extractorThreadSwitch(hybridMode = false, priority?: string): string {
|
|
if (hybridMode) {
|
|
const envValue = Number(process.env.RD_EXTRACT_THREADS ?? NaN);
|
|
if (Number.isFinite(envValue) && envValue >= 1 && envValue <= 32) {
|
|
return `-mt${Math.floor(envValue)}`;
|
|
}
|
|
const cpuCount = Math.max(1, os.cpus().length || 1);
|
|
const hybridThreads = Math.max(2, Math.min(12, Math.ceil(cpuCount * 0.75)));
|
|
return `-mt${hybridThreads}`;
|
|
}
|
|
const envValue = Number(process.env.RD_EXTRACT_THREADS ?? NaN);
|
|
if (Number.isFinite(envValue) && envValue >= 1 && envValue <= 32) {
|
|
return `-mt${Math.floor(envValue)}`;
|
|
}
|
|
const cpuCount = Math.max(1, os.cpus().length || 1);
|
|
const budgetPercent = extractCpuBudgetPercent(priority);
|
|
const budgetedThreads = Math.floor((cpuCount * budgetPercent) / 100);
|
|
const threadCount = Math.max(1, Math.min(16, Math.max(1, budgetedThreads)));
|
|
return `-mt${threadCount}`;
|
|
}
|
|
|
|
function lowerExtractProcessPriority(childPid: number | undefined, cpuPriority?: string): void {
|
|
if (process.platform !== "win32") {
|
|
return;
|
|
}
|
|
const pid = Number(childPid || 0);
|
|
if (!Number.isFinite(pid) || pid <= 0) {
|
|
return;
|
|
}
|
|
try {
|
|
os.setPriority(pid, extractOsPriority(cpuPriority));
|
|
} catch {
|
|
}
|
|
}
|
|
|
|
function killProcessTree(child: { pid?: number; kill: () => void }): void {
|
|
const pid = Number(child.pid || 0);
|
|
if (!Number.isFinite(pid) || pid <= 0) {
|
|
try {
|
|
child.kill();
|
|
} catch {
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (process.platform === "win32") {
|
|
try {
|
|
const killer = spawn("taskkill", ["/PID", String(pid), "/T", "/F"], {
|
|
windowsHide: true,
|
|
stdio: "ignore"
|
|
});
|
|
killer.on("error", () => {
|
|
try {
|
|
child.kill();
|
|
} catch {
|
|
}
|
|
});
|
|
} catch {
|
|
try {
|
|
child.kill();
|
|
} catch {
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
try {
|
|
child.kill();
|
|
} catch {
|
|
}
|
|
}
|
|
|
|
function parseProgressPercent(chunk: string): number | null {
|
|
const text = String(chunk || "");
|
|
const matches = text.match(/(?:^|\D)(\d{1,3})%/g);
|
|
if (!matches) {
|
|
return null;
|
|
}
|
|
let latest: number | null = null;
|
|
for (const raw of matches) {
|
|
const digits = raw.match(/(\d{1,3})%/);
|
|
if (!digits) {
|
|
continue;
|
|
}
|
|
const value = Number(digits[1]);
|
|
if (Number.isFinite(value) && value >= 0 && value <= 100) {
|
|
latest = value;
|
|
}
|
|
}
|
|
return latest;
|
|
}
|
|
|
|
function nextArchivePercent(previous: number, incoming: number): number {
|
|
const prev = Math.max(0, Math.min(100, Math.floor(Number(previous) || 0)));
|
|
const next = Math.max(0, Math.min(100, Math.floor(Number(incoming) || 0)));
|
|
return next >= prev ? next : prev;
|
|
}
|
|
|
|
function runExtractCommand(
|
|
command: string,
|
|
args: string[],
|
|
onChunk?: (chunk: string) => void,
|
|
signal?: AbortSignal,
|
|
timeoutMs?: number
|
|
): Promise<ExtractSpawnResult> {
|
|
if (signal?.aborted) {
|
|
return Promise.resolve({ ok: false, missingCommand: false, aborted: true, timedOut: false, errorText: "aborted:extract" });
|
|
}
|
|
|
|
return new Promise((resolve) => {
|
|
let settled = false;
|
|
let output = "";
|
|
const child = spawn(command, args, { windowsHide: true });
|
|
lowerExtractProcessPriority(child.pid, currentExtractCpuPriority);
|
|
let timeoutId: NodeJS.Timeout | null = null;
|
|
let timedOutByWatchdog = false;
|
|
let abortedBySignal = false;
|
|
|
|
const finish = (result: ExtractSpawnResult): void => {
|
|
if (settled) {
|
|
return;
|
|
}
|
|
settled = true;
|
|
if (timeoutId) {
|
|
clearTimeout(timeoutId);
|
|
timeoutId = null;
|
|
}
|
|
if (signal && onAbort) {
|
|
signal.removeEventListener("abort", onAbort);
|
|
}
|
|
resolve(result);
|
|
};
|
|
|
|
if (timeoutMs && timeoutMs > 0) {
|
|
timeoutId = setTimeout(() => {
|
|
timedOutByWatchdog = true;
|
|
killProcessTree(child);
|
|
finish({
|
|
ok: false,
|
|
missingCommand: false,
|
|
aborted: false,
|
|
timedOut: true,
|
|
errorText: `Entpacken Timeout nach ${Math.ceil(timeoutMs / 1000)}s`
|
|
});
|
|
}, timeoutMs);
|
|
}
|
|
|
|
const onAbort = signal
|
|
? (): void => {
|
|
abortedBySignal = true;
|
|
killProcessTree(child);
|
|
finish({ ok: false, missingCommand: false, aborted: true, timedOut: false, errorText: "aborted:extract" });
|
|
}
|
|
: null;
|
|
if (signal && onAbort) {
|
|
signal.addEventListener("abort", onAbort, { once: true });
|
|
}
|
|
|
|
child.stdout.on("data", (chunk) => {
|
|
const text = String(chunk || "");
|
|
output = appendLimited(output, text);
|
|
onChunk?.(text);
|
|
});
|
|
child.stderr.on("data", (chunk) => {
|
|
const text = String(chunk || "");
|
|
output = appendLimited(output, text);
|
|
onChunk?.(text);
|
|
});
|
|
|
|
child.on("error", (error) => {
|
|
const text = cleanErrorText(String(error));
|
|
finish({
|
|
ok: false,
|
|
missingCommand: text.toLowerCase().includes("enoent"),
|
|
aborted: false,
|
|
timedOut: false,
|
|
errorText: text
|
|
});
|
|
});
|
|
|
|
child.on("close", (code) => {
|
|
if (abortedBySignal) {
|
|
finish({ ok: false, missingCommand: false, aborted: true, timedOut: false, errorText: "aborted:extract" });
|
|
return;
|
|
}
|
|
if (timedOutByWatchdog) {
|
|
finish({
|
|
ok: false,
|
|
missingCommand: false,
|
|
aborted: false,
|
|
timedOut: true,
|
|
errorText: `Entpacken Timeout nach ${Math.ceil((timeoutMs || 0) / 1000)}s`
|
|
});
|
|
return;
|
|
}
|
|
if (code === 0) {
|
|
finish({ ok: true, missingCommand: false, aborted: false, timedOut: false, errorText: "" });
|
|
return;
|
|
}
|
|
if (code === 1) {
|
|
const lowered = output.toLowerCase();
|
|
const warningOnly = !lowered.includes("crc failed")
|
|
&& !lowered.includes("checksum error")
|
|
&& !lowered.includes("wrong password")
|
|
&& !lowered.includes("cannot open")
|
|
&& !lowered.includes("fatal error")
|
|
&& !lowered.includes("unexpected end of archive")
|
|
&& !lowered.includes("error:");
|
|
if (warningOnly) {
|
|
finish({ ok: true, missingCommand: false, aborted: false, timedOut: false, errorText: "" });
|
|
return;
|
|
}
|
|
}
|
|
const cleaned = cleanErrorText(output);
|
|
finish({
|
|
ok: false,
|
|
missingCommand: false,
|
|
aborted: false,
|
|
timedOut: false,
|
|
errorText: cleaned || `Exit Code ${String(code ?? "?")}`
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
let cachedJvmLayout: JvmExtractorLayout | null | undefined;
|
|
let cachedJvmLayoutNullSince = 0;
|
|
const JVM_LAYOUT_NULL_TTL_MS = 5 * 60 * 1000;
|
|
|
|
function resolveJavaCommandCandidates(): string[] {
|
|
const programFiles = process.env.ProgramFiles || "C:\\Program Files";
|
|
const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)";
|
|
const localAppData = process.env.LOCALAPPDATA || "";
|
|
|
|
const candidates = [
|
|
process.env.RD_JAVA_BIN || "",
|
|
path.join(programFiles, "JDownloader", "jre", "bin", "java.exe"),
|
|
path.join(programFilesX86, "JDownloader", "jre", "bin", "java.exe"),
|
|
localAppData ? path.join(localAppData, "JDownloader", "jre", "bin", "java.exe") : "",
|
|
"java"
|
|
].filter(Boolean);
|
|
|
|
return Array.from(new Set(candidates));
|
|
}
|
|
|
|
function resolveJvmExtractorRootCandidates(): string[] {
|
|
const fromEnv = String(process.env.RD_EXTRACTOR_JVM_DIR || "").trim();
|
|
const electronResourcesPath = (process as NodeJS.Process & { resourcesPath?: string }).resourcesPath || "";
|
|
const candidates = [
|
|
fromEnv,
|
|
electronResourcesPath ? path.join(electronResourcesPath, "app.asar.unpacked", "resources", "extractor-jvm") : "",
|
|
path.join(process.cwd(), "resources", "extractor-jvm"),
|
|
path.join(process.cwd(), "build", "resources", "extractor-jvm"),
|
|
path.join(__dirname, "..", "..", "..", "resources", "extractor-jvm"),
|
|
electronResourcesPath ? path.join(electronResourcesPath, "extractor-jvm") : ""
|
|
].filter(Boolean);
|
|
return Array.from(new Set(candidates));
|
|
}
|
|
|
|
function resolveJvmExtractorLayout(): JvmExtractorLayout | null {
|
|
if (cachedJvmLayout !== undefined) {
|
|
if (cachedJvmLayout === null && Date.now() - cachedJvmLayoutNullSince > JVM_LAYOUT_NULL_TTL_MS) {
|
|
cachedJvmLayout = undefined;
|
|
} else {
|
|
return cachedJvmLayout;
|
|
}
|
|
}
|
|
const javaCandidates = resolveJavaCommandCandidates();
|
|
const javaCommand = javaCandidates.find((candidate) => {
|
|
if (!candidate) {
|
|
return false;
|
|
}
|
|
if (!isAbsoluteCommand(candidate)) {
|
|
return true;
|
|
}
|
|
return fs.existsSync(candidate);
|
|
}) || "";
|
|
|
|
if (!javaCommand) {
|
|
cachedJvmLayout = null;
|
|
cachedJvmLayoutNullSince = Date.now();
|
|
return null;
|
|
}
|
|
|
|
for (const rootDir of resolveJvmExtractorRootCandidates()) {
|
|
const classesDir = path.join(rootDir, JVM_EXTRACTOR_CLASSES_SUBDIR);
|
|
if (!fs.existsSync(classesDir)) {
|
|
continue;
|
|
}
|
|
const libs = JVM_EXTRACTOR_REQUIRED_LIBS.map((name) => path.join(rootDir, JVM_EXTRACTOR_LIB_SUBDIR, name));
|
|
if (libs.some((filePath) => !fs.existsSync(filePath))) {
|
|
continue;
|
|
}
|
|
const classPath = [classesDir, ...libs].join(path.delimiter);
|
|
const layout = { javaCommand, classPath, rootDir };
|
|
cachedJvmLayout = layout;
|
|
return layout;
|
|
}
|
|
|
|
cachedJvmLayout = null;
|
|
cachedJvmLayoutNullSince = Date.now();
|
|
return null;
|
|
}
|
|
|
|
function parseJvmLine(
|
|
line: string,
|
|
onArchiveProgress: ((percent: number) => void) | undefined,
|
|
state: { bestPercent: number; usedPassword: string; backend: string; reportedError: string }
|
|
): void {
|
|
const trimmed = String(line || "").trim();
|
|
if (!trimmed) {
|
|
return;
|
|
}
|
|
|
|
if (trimmed.startsWith("RD_PROGRESS ")) {
|
|
const parsed = parseProgressPercent(trimmed);
|
|
if (parsed !== null) {
|
|
const next = nextArchivePercent(state.bestPercent, parsed);
|
|
if (next !== state.bestPercent) {
|
|
state.bestPercent = next;
|
|
onArchiveProgress?.(next);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (trimmed.startsWith("RD_PASSWORD ")) {
|
|
const encoded = trimmed.slice("RD_PASSWORD ".length).trim();
|
|
try {
|
|
state.usedPassword = Buffer.from(encoded, "base64").toString("utf8");
|
|
} catch {
|
|
state.usedPassword = "";
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (trimmed.startsWith("RD_BACKEND ")) {
|
|
state.backend = trimmed.slice("RD_BACKEND ".length).trim();
|
|
return;
|
|
}
|
|
|
|
if (trimmed.startsWith("RD_ERROR ")) {
|
|
state.reportedError = trimmed.slice("RD_ERROR ".length).trim();
|
|
}
|
|
}
|
|
|
|
let daemonProcess: ChildProcess | null = null;
|
|
let daemonReady = false;
|
|
let daemonBusy = false;
|
|
let daemonCurrentRequest: DaemonRequest | null = null;
|
|
let daemonStdoutBuffer = "";
|
|
let daemonStderrBuffer = "";
|
|
let daemonOutput = "";
|
|
let daemonTimeoutId: NodeJS.Timeout | null = null;
|
|
let daemonAbortHandler: (() => void) | null = null;
|
|
let daemonLayout: JvmExtractorLayout | null = null;
|
|
|
|
export function shutdownDaemon(): void {
|
|
if (daemonProcess) {
|
|
try { daemonProcess.stdin?.end(); } catch { }
|
|
try { killProcessTree(daemonProcess); } catch { }
|
|
daemonProcess = null;
|
|
}
|
|
daemonReady = false;
|
|
daemonBusy = false;
|
|
daemonCurrentRequest = null;
|
|
daemonStdoutBuffer = "";
|
|
daemonStderrBuffer = "";
|
|
daemonOutput = "";
|
|
if (daemonTimeoutId) { clearTimeout(daemonTimeoutId); daemonTimeoutId = null; }
|
|
if (daemonAbortHandler) { daemonAbortHandler = null; }
|
|
daemonLayout = null;
|
|
}
|
|
|
|
function finishDaemonRequest(result: JvmExtractResult): void {
|
|
const req = daemonCurrentRequest;
|
|
if (!req) return;
|
|
daemonCurrentRequest = null;
|
|
daemonBusy = false;
|
|
daemonStdoutBuffer = "";
|
|
daemonStderrBuffer = "";
|
|
daemonOutput = "";
|
|
if (daemonTimeoutId) { clearTimeout(daemonTimeoutId); daemonTimeoutId = null; }
|
|
if (req.signal && daemonAbortHandler) {
|
|
req.signal.removeEventListener("abort", daemonAbortHandler);
|
|
daemonAbortHandler = null;
|
|
}
|
|
req.resolve(result);
|
|
}
|
|
|
|
function flushDaemonParseBuffers(req: DaemonRequest | null): void {
|
|
if (!req) {
|
|
return;
|
|
}
|
|
if (daemonStdoutBuffer.trim()) {
|
|
parseJvmLine(daemonStdoutBuffer, req.onArchiveProgress, req.parseState);
|
|
daemonStdoutBuffer = "";
|
|
}
|
|
if (daemonStderrBuffer.trim()) {
|
|
parseJvmLine(daemonStderrBuffer, req.onArchiveProgress, req.parseState);
|
|
daemonStderrBuffer = "";
|
|
}
|
|
}
|
|
|
|
function handleDaemonLine(line: string): void {
|
|
const trimmed = String(line || "").trim();
|
|
if (!trimmed) return;
|
|
|
|
if (trimmed === "RD_DAEMON_READY") {
|
|
daemonReady = true;
|
|
logger.info("JVM Daemon bereit (persistent)");
|
|
return;
|
|
}
|
|
|
|
if (trimmed.startsWith("RD_REQUEST_DONE ")) {
|
|
const code = parseInt(trimmed.slice("RD_REQUEST_DONE ".length).trim(), 10);
|
|
const req = daemonCurrentRequest;
|
|
if (!req) return;
|
|
const finalize = (): void => {
|
|
if (daemonCurrentRequest !== req) {
|
|
return;
|
|
}
|
|
flushDaemonParseBuffers(req);
|
|
const elapsedMs = Date.now() - req.startedAt;
|
|
logger.info(
|
|
`JVM Daemon Request Ende: archive=${req.archiveName}, code=${code}, ms=${elapsedMs}, pwCandidates=${req.passwordCount}, ` +
|
|
`bestPercent=${req.parseState.bestPercent}, backend=${req.parseState.backend || "unknown"}, usedPassword=${req.parseState.usedPassword ? "yes" : "no"}`
|
|
);
|
|
|
|
if (code === 0) {
|
|
req.onArchiveProgress?.(100);
|
|
finishDaemonRequest({
|
|
ok: true, missingCommand: false, missingRuntime: false,
|
|
aborted: false, timedOut: false, errorText: "",
|
|
usedPassword: req.parseState.usedPassword, backend: req.parseState.backend
|
|
});
|
|
return;
|
|
}
|
|
|
|
const message = cleanErrorText(req.parseState.reportedError || daemonOutput) || `Exit Code ${code}`;
|
|
finishDaemonRequest({
|
|
ok: false, missingCommand: false, missingRuntime: isJvmRuntimeMissingError(message),
|
|
aborted: false, timedOut: false, errorText: message,
|
|
usedPassword: req.parseState.usedPassword, backend: req.parseState.backend
|
|
});
|
|
};
|
|
|
|
if (code !== 0 && !req.parseState.reportedError) {
|
|
setTimeout(finalize, 40);
|
|
return;
|
|
}
|
|
|
|
finalize();
|
|
return;
|
|
}
|
|
|
|
if (daemonCurrentRequest) {
|
|
parseJvmLine(trimmed, daemonCurrentRequest.onArchiveProgress, daemonCurrentRequest.parseState);
|
|
}
|
|
}
|
|
|
|
function startDaemon(layout: JvmExtractorLayout): boolean {
|
|
if (daemonProcess && daemonReady) return true;
|
|
if (daemonProcess) return false;
|
|
shutdownDaemon();
|
|
|
|
const jvmTmpDir = path.join(os.tmpdir(), `rd-extract-daemon-${crypto.randomUUID()}`);
|
|
fs.mkdirSync(jvmTmpDir, { recursive: true });
|
|
|
|
const args = [
|
|
"-Dfile.encoding=UTF-8",
|
|
`-Djava.io.tmpdir=${jvmTmpDir}`,
|
|
"-Xms1g",
|
|
jvmMaxHeapArg(),
|
|
"-XX:+UseG1GC",
|
|
"-XX:MaxGCPauseMillis=50",
|
|
"-cp",
|
|
layout.classPath,
|
|
JVM_EXTRACTOR_MAIN_CLASS,
|
|
"--daemon"
|
|
];
|
|
|
|
try {
|
|
const child = spawn(layout.javaCommand, args, {
|
|
windowsHide: true,
|
|
stdio: ["pipe", "pipe", "pipe"]
|
|
});
|
|
lowerExtractProcessPriority(child.pid, currentExtractCpuPriority);
|
|
daemonProcess = child;
|
|
daemonLayout = layout;
|
|
|
|
child.stdout!.on("data", (chunk) => {
|
|
const raw = String(chunk || "");
|
|
daemonOutput = appendLimited(daemonOutput, raw);
|
|
daemonStdoutBuffer += raw;
|
|
const lines = daemonStdoutBuffer.split(/\r?\n/);
|
|
daemonStdoutBuffer = lines.pop() || "";
|
|
for (const line of lines) {
|
|
handleDaemonLine(line);
|
|
}
|
|
});
|
|
|
|
child.stderr!.on("data", (chunk) => {
|
|
const raw = String(chunk || "");
|
|
daemonOutput = appendLimited(daemonOutput, raw);
|
|
daemonStderrBuffer += raw;
|
|
const lines = daemonStderrBuffer.split(/\r?\n/);
|
|
daemonStderrBuffer = lines.pop() || "";
|
|
for (const line of lines) {
|
|
if (daemonCurrentRequest) {
|
|
parseJvmLine(line, daemonCurrentRequest.onArchiveProgress, daemonCurrentRequest.parseState);
|
|
}
|
|
}
|
|
});
|
|
|
|
child.on("error", () => {
|
|
if (daemonCurrentRequest) {
|
|
finishDaemonRequest({
|
|
ok: false, missingCommand: true, missingRuntime: true,
|
|
aborted: false, timedOut: false, errorText: "Daemon process error",
|
|
usedPassword: "", backend: ""
|
|
});
|
|
}
|
|
shutdownDaemon();
|
|
});
|
|
|
|
child.on("close", () => {
|
|
if (daemonCurrentRequest) {
|
|
const req = daemonCurrentRequest;
|
|
finishDaemonRequest({
|
|
ok: false, missingCommand: false, missingRuntime: false,
|
|
aborted: false, timedOut: false,
|
|
errorText: cleanErrorText(req.parseState.reportedError || daemonOutput) || "Daemon process exited unexpectedly",
|
|
usedPassword: req.parseState.usedPassword, backend: req.parseState.backend
|
|
});
|
|
}
|
|
fs.rm(jvmTmpDir, { recursive: true, force: true }, () => {});
|
|
daemonProcess = null;
|
|
daemonReady = false;
|
|
daemonBusy = false;
|
|
daemonLayout = null;
|
|
});
|
|
|
|
logger.info(`JVM Daemon gestartet (PID ${child.pid})`);
|
|
return true;
|
|
} catch (error) {
|
|
logger.warn(`JVM Daemon Start fehlgeschlagen: ${String(error)}`);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function isDaemonAvailable(layout: JvmExtractorLayout): boolean {
|
|
if (!daemonProcess || !daemonReady) {
|
|
startDaemon(layout);
|
|
}
|
|
return Boolean(daemonProcess && daemonReady && !daemonBusy);
|
|
}
|
|
|
|
function waitForDaemonReady(maxWaitMs: number, signal?: AbortSignal): Promise<boolean> {
|
|
return new Promise((resolve) => {
|
|
const start = Date.now();
|
|
const check = () => {
|
|
if (signal?.aborted) { resolve(false); return; }
|
|
if (daemonProcess && daemonReady && !daemonBusy) { resolve(true); return; }
|
|
if (!daemonProcess) { resolve(false); return; }
|
|
if (Date.now() - start >= maxWaitMs) { resolve(false); return; }
|
|
setTimeout(check, 50);
|
|
};
|
|
check();
|
|
});
|
|
}
|
|
|
|
function sendDaemonRequest(
|
|
archivePath: string,
|
|
targetDir: string,
|
|
conflictMode: ConflictMode,
|
|
passwordCandidates: string[],
|
|
onArchiveProgress?: (percent: number) => void,
|
|
signal?: AbortSignal,
|
|
timeoutMs?: number
|
|
): Promise<JvmExtractResult> {
|
|
return new Promise((resolve) => {
|
|
const mode = effectiveConflictMode(conflictMode);
|
|
const parseState = { bestPercent: 0, usedPassword: "", backend: "", reportedError: "" };
|
|
const archiveName = path.basename(archivePath);
|
|
|
|
daemonBusy = true;
|
|
daemonOutput = "";
|
|
daemonCurrentRequest = {
|
|
resolve,
|
|
onArchiveProgress,
|
|
signal,
|
|
timeoutMs,
|
|
parseState,
|
|
archiveName,
|
|
startedAt: Date.now(),
|
|
passwordCount: passwordCandidates.length
|
|
};
|
|
logger.info(`JVM Daemon Request Start: archive=${archiveName}, pwCandidates=${passwordCandidates.length}, timeoutMs=${timeoutMs || 0}, conflict=${mode}`);
|
|
|
|
if (timeoutMs && timeoutMs > 0) {
|
|
daemonTimeoutId = setTimeout(() => {
|
|
const req = daemonCurrentRequest;
|
|
if (req) {
|
|
finishDaemonRequest({
|
|
ok: false, missingCommand: false, missingRuntime: false,
|
|
aborted: false, timedOut: true,
|
|
errorText: `Entpacken Timeout nach ${Math.ceil(timeoutMs / 1000)}s`,
|
|
usedPassword: parseState.usedPassword, backend: parseState.backend
|
|
});
|
|
}
|
|
shutdownDaemon();
|
|
}, timeoutMs);
|
|
}
|
|
|
|
if (signal) {
|
|
daemonAbortHandler = () => {
|
|
const req = daemonCurrentRequest;
|
|
if (req) {
|
|
finishDaemonRequest({
|
|
ok: false, missingCommand: false, missingRuntime: false,
|
|
aborted: true, timedOut: false, errorText: "aborted:extract",
|
|
usedPassword: parseState.usedPassword, backend: parseState.backend
|
|
});
|
|
}
|
|
shutdownDaemon();
|
|
};
|
|
signal.addEventListener("abort", daemonAbortHandler, { once: true });
|
|
}
|
|
|
|
const jsonRequest = JSON.stringify({
|
|
archive: archivePath,
|
|
target: targetDir,
|
|
conflict: mode,
|
|
backend: "auto",
|
|
passwords: passwordCandidates
|
|
});
|
|
|
|
try {
|
|
daemonProcess!.stdin!.write(jsonRequest + "\n");
|
|
} catch (error) {
|
|
finishDaemonRequest({
|
|
ok: false, missingCommand: false, missingRuntime: false,
|
|
aborted: false, timedOut: false,
|
|
errorText: `Daemon stdin write failed: ${String(error)}`,
|
|
usedPassword: "", backend: ""
|
|
});
|
|
shutdownDaemon();
|
|
}
|
|
});
|
|
}
|
|
|
|
async function runJvmExtractCommand(
|
|
layout: JvmExtractorLayout,
|
|
archivePath: string,
|
|
targetDir: string,
|
|
conflictMode: ConflictMode,
|
|
passwordCandidates: string[],
|
|
onArchiveProgress?: (percent: number) => void,
|
|
signal?: AbortSignal,
|
|
timeoutMs?: number
|
|
): Promise<JvmExtractResult> {
|
|
if (signal?.aborted) {
|
|
return Promise.resolve({
|
|
ok: false, missingCommand: false, missingRuntime: false,
|
|
aborted: true, timedOut: false, errorText: "aborted:extract",
|
|
usedPassword: "", backend: ""
|
|
});
|
|
}
|
|
|
|
if (isDaemonAvailable(layout)) {
|
|
lowerExtractProcessPriority(daemonProcess?.pid, currentExtractCpuPriority);
|
|
logger.info(`JVM Daemon: Sofort verfügbar, sende Request für ${path.basename(archivePath)} (pwCandidates=${passwordCandidates.length})`);
|
|
return sendDaemonRequest(archivePath, targetDir, conflictMode, passwordCandidates, onArchiveProgress, signal, timeoutMs);
|
|
}
|
|
|
|
if (daemonProcess) {
|
|
const reason = !daemonReady ? "booting" : "busy";
|
|
const waitStartedAt = Date.now();
|
|
logger.info(`JVM Daemon: Warte auf ${reason} Daemon für ${path.basename(archivePath)}...`);
|
|
const ready = await waitForDaemonReady(15_000, signal);
|
|
const waitedMs = Date.now() - waitStartedAt;
|
|
if (ready) {
|
|
lowerExtractProcessPriority(daemonProcess?.pid, currentExtractCpuPriority);
|
|
logger.info(`JVM Daemon: Bereit nach ${waitedMs}ms — sende Request für ${path.basename(archivePath)}`);
|
|
return sendDaemonRequest(archivePath, targetDir, conflictMode, passwordCandidates, onArchiveProgress, signal, timeoutMs);
|
|
}
|
|
logger.warn(`JVM Daemon: Timeout nach ${waitedMs}ms beim Warten — Fallback auf neuen Prozess für ${path.basename(archivePath)}`);
|
|
}
|
|
|
|
logger.info(`JVM Spawn: Neuer Prozess für ${path.basename(archivePath)}`);
|
|
|
|
const mode = effectiveConflictMode(conflictMode);
|
|
const jvmTmpDir = path.join(os.tmpdir(), `rd-extract-${crypto.randomUUID()}`);
|
|
fs.mkdirSync(jvmTmpDir, { recursive: true });
|
|
const args = [
|
|
"-Dfile.encoding=UTF-8",
|
|
`-Djava.io.tmpdir=${jvmTmpDir}`,
|
|
"-Xms1g",
|
|
jvmMaxHeapArg(),
|
|
"-XX:+UseG1GC",
|
|
"-XX:MaxGCPauseMillis=50",
|
|
"-cp",
|
|
layout.classPath,
|
|
JVM_EXTRACTOR_MAIN_CLASS,
|
|
"--archive",
|
|
archivePath,
|
|
"--target",
|
|
targetDir,
|
|
"--conflict",
|
|
mode,
|
|
"--backend",
|
|
"auto"
|
|
];
|
|
for (const password of passwordCandidates) {
|
|
args.push("--password", password);
|
|
}
|
|
|
|
return new Promise((resolve) => {
|
|
let settled = false;
|
|
let output = "";
|
|
let timeoutId: NodeJS.Timeout | null = null;
|
|
let timedOutByWatchdog = false;
|
|
let abortedBySignal = false;
|
|
let onAbort: (() => void) | null = null;
|
|
const parseState = { bestPercent: 0, usedPassword: "", backend: "", reportedError: "" };
|
|
let stdoutBuffer = "";
|
|
let stderrBuffer = "";
|
|
|
|
const child = spawn(layout.javaCommand, args, { windowsHide: true });
|
|
lowerExtractProcessPriority(child.pid, currentExtractCpuPriority);
|
|
|
|
const flushLines = (rawChunk: string, fromStdErr = false): void => {
|
|
if (!rawChunk) {
|
|
return;
|
|
}
|
|
output = appendLimited(output, rawChunk);
|
|
const nextBuffer = `${fromStdErr ? stderrBuffer : stdoutBuffer}${rawChunk}`;
|
|
const lines = nextBuffer.split(/\r?\n/);
|
|
const keep = lines.pop() || "";
|
|
for (const line of lines) {
|
|
parseJvmLine(line, onArchiveProgress, parseState);
|
|
}
|
|
if (fromStdErr) {
|
|
stderrBuffer = keep;
|
|
} else {
|
|
stdoutBuffer = keep;
|
|
}
|
|
};
|
|
|
|
const cleanupTmpDir = (): void => {
|
|
fs.rm(jvmTmpDir, { recursive: true, force: true }, () => {});
|
|
};
|
|
|
|
const finish = (result: JvmExtractResult): void => {
|
|
if (settled) {
|
|
return;
|
|
}
|
|
settled = true;
|
|
if (timeoutId) {
|
|
clearTimeout(timeoutId);
|
|
timeoutId = null;
|
|
}
|
|
if (signal && onAbort) {
|
|
signal.removeEventListener("abort", onAbort);
|
|
}
|
|
cleanupTmpDir();
|
|
resolve(result);
|
|
};
|
|
|
|
if (timeoutMs && timeoutMs > 0) {
|
|
timeoutId = setTimeout(() => {
|
|
timedOutByWatchdog = true;
|
|
killProcessTree(child);
|
|
finish({
|
|
ok: false, missingCommand: false, missingRuntime: false,
|
|
aborted: false, timedOut: true,
|
|
errorText: `Entpacken Timeout nach ${Math.ceil(timeoutMs / 1000)}s`,
|
|
usedPassword: parseState.usedPassword, backend: parseState.backend
|
|
});
|
|
}, timeoutMs);
|
|
}
|
|
|
|
onAbort = signal
|
|
? (): void => {
|
|
abortedBySignal = true;
|
|
killProcessTree(child);
|
|
finish({
|
|
ok: false, missingCommand: false, missingRuntime: false,
|
|
aborted: true, timedOut: false, errorText: "aborted:extract",
|
|
usedPassword: parseState.usedPassword, backend: parseState.backend
|
|
});
|
|
}
|
|
: null;
|
|
|
|
if (signal && onAbort) {
|
|
signal.addEventListener("abort", onAbort, { once: true });
|
|
}
|
|
|
|
child.stdout.on("data", (chunk) => {
|
|
flushLines(String(chunk || ""), false);
|
|
});
|
|
child.stderr.on("data", (chunk) => {
|
|
flushLines(String(chunk || ""), true);
|
|
});
|
|
|
|
child.on("error", (error) => {
|
|
const text = cleanErrorText(String(error));
|
|
finish({
|
|
ok: false, missingCommand: text.toLowerCase().includes("enoent"),
|
|
missingRuntime: true, aborted: false, timedOut: false,
|
|
errorText: text, usedPassword: parseState.usedPassword, backend: parseState.backend
|
|
});
|
|
});
|
|
|
|
child.on("close", (code) => {
|
|
parseJvmLine(stdoutBuffer, onArchiveProgress, parseState);
|
|
parseJvmLine(stderrBuffer, onArchiveProgress, parseState);
|
|
|
|
if (abortedBySignal) {
|
|
finish({
|
|
ok: false, missingCommand: false, missingRuntime: false,
|
|
aborted: true, timedOut: false, errorText: "aborted:extract",
|
|
usedPassword: parseState.usedPassword, backend: parseState.backend
|
|
});
|
|
return;
|
|
}
|
|
if (timedOutByWatchdog) {
|
|
finish({
|
|
ok: false, missingCommand: false, missingRuntime: false,
|
|
aborted: false, timedOut: true,
|
|
errorText: `Entpacken Timeout nach ${Math.ceil((timeoutMs || 0) / 1000)}s`,
|
|
usedPassword: parseState.usedPassword, backend: parseState.backend
|
|
});
|
|
return;
|
|
}
|
|
|
|
const message = cleanErrorText(parseState.reportedError || output) || `Exit Code ${String(code ?? "?")}`;
|
|
if (code === 0) {
|
|
onArchiveProgress?.(100);
|
|
finish({
|
|
ok: true, missingCommand: false, missingRuntime: false,
|
|
aborted: false, timedOut: false, errorText: "",
|
|
usedPassword: parseState.usedPassword, backend: parseState.backend
|
|
});
|
|
return;
|
|
}
|
|
|
|
finish({
|
|
ok: false, missingCommand: false,
|
|
missingRuntime: isJvmRuntimeMissingError(message),
|
|
aborted: false, timedOut: false, errorText: message,
|
|
usedPassword: parseState.usedPassword, backend: parseState.backend
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
export function buildExternalExtractArgs(
|
|
command: string,
|
|
archivePath: string,
|
|
targetDir: string,
|
|
conflictMode: ConflictMode,
|
|
password = "",
|
|
usePerformanceFlags = true,
|
|
hybridMode = false,
|
|
flatMode = false
|
|
): string[] {
|
|
const mode = effectiveConflictMode(conflictMode);
|
|
if (isRarNativeCommand(command)) {
|
|
const extractCmd = flatMode ? "e" : "x";
|
|
const overwrite = mode === "overwrite" ? "-o+" : mode === "rename" ? "-or" : "-o-";
|
|
const pass = password ? `-p${password}` : "-p-";
|
|
const perfArgs = usePerformanceFlags && shouldUseExtractorPerformanceFlags()
|
|
? ["-idc", extractorThreadSwitch(hybridMode, currentExtractCpuPriority)]
|
|
: [];
|
|
return [extractCmd, overwrite, pass, "-y", ...perfArgs, archivePath, `${targetDir}${path.sep}`];
|
|
}
|
|
|
|
const overwrite = mode === "overwrite" ? "-aoa" : mode === "rename" ? "-aou" : "-aos";
|
|
const pass = password ? `-p${password}` : "-p";
|
|
return ["x", "-y", overwrite, pass, archivePath, `-o${targetDir}`];
|
|
}
|
|
|
|
const extractRetryDelay = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
|
|
|
|
async function runExternalExtractInner(
|
|
command: string,
|
|
archivePath: string,
|
|
targetDir: string,
|
|
conflictMode: ConflictMode,
|
|
passwordCandidates: string[],
|
|
onArchiveProgress: ((percent: number) => void) | undefined,
|
|
signal: AbortSignal | undefined,
|
|
timeoutMs: number,
|
|
hybridMode = false,
|
|
onPasswordAttempt?: (attempt: number, total: number) => void,
|
|
forceFlatMode = false,
|
|
flatModeResult?: { needed: boolean },
|
|
onLog?: ExtractOptions["onLog"]
|
|
): Promise<string> {
|
|
const passwords = passwordCandidates;
|
|
let lastError = "";
|
|
const extractorName = path.basename(command).replace(/\.exe$/i, "") || command;
|
|
|
|
const emptyPasswordCount = passwords.filter((candidate) => candidate === "").length;
|
|
onLog?.("INFO", `Legacy-Extractor Start: archive=${path.basename(archivePath)}, extractor=${extractorName}, passwordCount=${passwords.length}, forceFlatMode=${forceFlatMode}, targetDir=${targetDir}`);
|
|
logger.info(`Legacy-Extractor (${extractorName}): ${path.basename(archivePath)}, passwordCount=${passwords.length}, redacted=true, emptyCandidates=${emptyPasswordCount}${forceFlatMode ? " (flat-mode cached)" : ""}`);
|
|
|
|
let announcedStart = false;
|
|
let bestPercent = 0;
|
|
let passwordAttempt = 0;
|
|
let usePerformanceFlags = externalExtractorSupportsPerfFlags && shouldUseExtractorPerformanceFlags();
|
|
const summarizeResultError = (errorText: string): string => cleanErrorText(errorText);
|
|
let createErrorText = "";
|
|
let createErrorPassword = "";
|
|
|
|
if (forceFlatMode) {
|
|
logger.info(`Flat-Modus direkt (gespeichert vom vorherigen Archiv): ${path.basename(archivePath)}`);
|
|
onLog?.("INFO", `Flat-Modus direkt (gespeichert vom vorherigen Archiv): ${path.basename(archivePath)}`);
|
|
for (const password of passwords) {
|
|
if (signal?.aborted) throw new Error("aborted:extract");
|
|
passwordAttempt += 1;
|
|
onLog?.("INFO", `Flach-Extraktion Versuch ${passwordAttempt}/${passwords.length}: archive=${path.basename(archivePath)}, password=<redacted>`);
|
|
logger.info(`Flach-Extraktion Versuch ${passwordAttempt}/${passwords.length} für ${path.basename(archivePath)} (password=<redacted>)`);
|
|
const args = buildExternalExtractArgs(command, archivePath, targetDir, conflictMode, password, usePerformanceFlags, hybridMode, true);
|
|
const result = await runExtractCommand(command, args, (chunk) => {
|
|
const parsed = parseProgressPercent(chunk);
|
|
if (parsed === null) return;
|
|
const next = nextArchivePercent(bestPercent, parsed);
|
|
if (next !== bestPercent) { bestPercent = next; onArchiveProgress?.(bestPercent); }
|
|
}, signal, timeoutMs);
|
|
logger.info(`Flach-Extraktion Versuch ${passwordAttempt}/${passwords.length}: ok=${result.ok}, bestPercent=${bestPercent}`);
|
|
onLog?.("INFO", `Flach-Extraktion Ergebnis ${passwordAttempt}/${passwords.length}: archive=${path.basename(archivePath)}, ok=${result.ok}, timedOut=${result.timedOut}, missingCommand=${result.missingCommand}, bestPercent=${bestPercent}`);
|
|
if (result.ok) { if (flatModeResult) flatModeResult.needed = true; onArchiveProgress?.(100); return password; }
|
|
if (result.aborted) throw new Error("aborted:extract");
|
|
if (result.timedOut || result.missingCommand) break;
|
|
lastError = result.errorText;
|
|
}
|
|
throw withExtractionErrorHints(new Error(lastError || "Entpacken fehlgeschlagen (flat-mode)"), { legacyBestPercent: bestPercent, legacyExtractor: extractorName });
|
|
}
|
|
|
|
for (const password of passwords) {
|
|
if (signal?.aborted) {
|
|
throw new Error("aborted:extract");
|
|
}
|
|
if (!announcedStart) {
|
|
announcedStart = true;
|
|
onArchiveProgress?.(0);
|
|
}
|
|
passwordAttempt += 1;
|
|
const attemptStartedAt = Date.now();
|
|
onLog?.("INFO", `Legacy-Passwort-Versuch ${passwordAttempt}/${passwords.length}: archive=${path.basename(archivePath)}, password=<redacted>`);
|
|
logger.info(`Legacy-Passwort-Versuch ${passwordAttempt}/${passwords.length} für ${path.basename(archivePath)} (password=<redacted>)`);
|
|
if (passwords.length > 1) {
|
|
onPasswordAttempt?.(passwordAttempt, passwords.length);
|
|
}
|
|
let args = buildExternalExtractArgs(command, archivePath, targetDir, conflictMode, password, usePerformanceFlags, hybridMode);
|
|
let result = await runExtractCommand(command, args, (chunk) => {
|
|
const parsed = parseProgressPercent(chunk);
|
|
if (parsed === null) {
|
|
return;
|
|
}
|
|
const next = nextArchivePercent(bestPercent, parsed);
|
|
if (next !== bestPercent) {
|
|
bestPercent = next;
|
|
onArchiveProgress?.(bestPercent);
|
|
}
|
|
}, signal, timeoutMs);
|
|
|
|
if (!result.ok && usePerformanceFlags && isUnsupportedExtractorSwitchError(result.errorText)) {
|
|
usePerformanceFlags = false;
|
|
externalExtractorSupportsPerfFlags = false;
|
|
onLog?.("WARN", `Entpacker ohne Performance-Flags fortgesetzt: ${path.basename(archivePath)}`);
|
|
logger.warn(`Entpacker ohne Performance-Flags fortgesetzt: ${path.basename(archivePath)}`);
|
|
args = buildExternalExtractArgs(command, archivePath, targetDir, conflictMode, password, false, hybridMode);
|
|
result = await runExtractCommand(command, args, (chunk) => {
|
|
const parsed = parseProgressPercent(chunk);
|
|
if (parsed === null) {
|
|
return;
|
|
}
|
|
const next = nextArchivePercent(bestPercent, parsed);
|
|
if (next !== bestPercent) {
|
|
bestPercent = next;
|
|
onArchiveProgress?.(bestPercent);
|
|
}
|
|
}, signal, timeoutMs);
|
|
}
|
|
|
|
logger.info(
|
|
`Legacy-Passwort-Versuch Ergebnis: archive=${path.basename(archivePath)}, attempt=${passwordAttempt}/${passwords.length}, ` +
|
|
`ms=${Date.now() - attemptStartedAt}, ok=${result.ok}, timedOut=${result.timedOut}, missingCommand=${result.missingCommand}, bestPercent=${bestPercent}`
|
|
);
|
|
onLog?.("INFO", `Legacy-Passwort-Versuch Ergebnis: archive=${path.basename(archivePath)}, attempt=${passwordAttempt}/${passwords.length}, ms=${Date.now() - attemptStartedAt}, ok=${result.ok}, timedOut=${result.timedOut}, missingCommand=${result.missingCommand}, bestPercent=${bestPercent}`);
|
|
if (!result.ok) {
|
|
const errorSummary = summarizeResultError(result.errorText);
|
|
if (errorSummary) {
|
|
logger.info(`Legacy-Passwort-Versuch Fehlertext: archive=${path.basename(archivePath)}, attempt=${passwordAttempt}/${passwords.length}, extractor=${extractorName}, error=${errorSummary}`);
|
|
onLog?.("INFO", `Legacy-Passwort-Versuch Fehlertext: archive=${path.basename(archivePath)}, attempt=${passwordAttempt}/${passwords.length}, extractor=${extractorName}, error=${errorSummary}`);
|
|
}
|
|
}
|
|
|
|
if (result.ok) {
|
|
onArchiveProgress?.(100);
|
|
return password;
|
|
}
|
|
|
|
if (!createErrorText && result.errorText.includes("Cannot create")) {
|
|
createErrorText = result.errorText;
|
|
createErrorPassword = password;
|
|
logger.warn(`Entpack-Pfadfehler gemerkt: archive=${path.basename(archivePath)}, attempt=${passwordAttempt}/${passwords.length}, extractor=${extractorName}, password=<redacted>`);
|
|
onLog?.("WARN", `Entpack-Pfadfehler gemerkt: archive=${path.basename(archivePath)}, attempt=${passwordAttempt}/${passwords.length}, extractor=${extractorName}, password=<redacted>`);
|
|
}
|
|
|
|
if (result.aborted) {
|
|
throw new Error("aborted:extract");
|
|
}
|
|
|
|
if (result.timedOut) {
|
|
lastError = result.errorText;
|
|
break;
|
|
}
|
|
|
|
if (result.missingCommand) {
|
|
resolvedExtractorCommand = null;
|
|
resolveFailureReason = NO_EXTRACTOR_MESSAGE;
|
|
resolveFailureAt = Date.now();
|
|
throw withExtractionErrorHints(new Error(NO_EXTRACTOR_MESSAGE), { legacyBestPercent: bestPercent, legacyExtractor: extractorName });
|
|
}
|
|
|
|
lastError = result.errorText;
|
|
}
|
|
|
|
const pathCreateError = createErrorText || (lastError.includes("Cannot create") ? lastError : "");
|
|
if (pathCreateError) {
|
|
const flatPasswords = createErrorPassword
|
|
? prioritizePassword(passwords, createErrorPassword)
|
|
: passwords;
|
|
logger.warn(`Entpack-Pfadfehler: Wiederholung mit flachem Modus: ${path.basename(archivePath)}`);
|
|
onLog?.("WARN", `Entpack-Pfadfehler: Wiederholung mit flachem Modus: ${path.basename(archivePath)}`);
|
|
bestPercent = 0;
|
|
passwordAttempt = 0;
|
|
lastError = pathCreateError;
|
|
for (const password of flatPasswords) {
|
|
if (signal?.aborted) throw new Error("aborted:extract");
|
|
passwordAttempt += 1;
|
|
logger.info(`Flach-Extraktion Versuch ${passwordAttempt}/${passwords.length} für ${path.basename(archivePath)} (password=<redacted>)`);
|
|
onLog?.("INFO", `Flach-Extraktion Versuch ${passwordAttempt}/${flatPasswords.length}: archive=${path.basename(archivePath)}, password=<redacted>`);
|
|
const args = buildExternalExtractArgs(command, archivePath, targetDir, conflictMode, password, usePerformanceFlags, hybridMode, true);
|
|
const result = await runExtractCommand(command, args, (chunk) => {
|
|
const parsed = parseProgressPercent(chunk);
|
|
if (parsed === null) return;
|
|
const next = nextArchivePercent(bestPercent, parsed);
|
|
if (next !== bestPercent) { bestPercent = next; onArchiveProgress?.(bestPercent); }
|
|
}, signal, timeoutMs);
|
|
logger.info(`Flach-Extraktion Versuch ${passwordAttempt}/${passwords.length}: ok=${result.ok}, bestPercent=${bestPercent}`);
|
|
onLog?.("INFO", `Flach-Extraktion Ergebnis ${passwordAttempt}/${flatPasswords.length}: archive=${path.basename(archivePath)}, ok=${result.ok}, timedOut=${result.timedOut}, missingCommand=${result.missingCommand}, bestPercent=${bestPercent}`);
|
|
if (result.ok) { if (flatModeResult) flatModeResult.needed = true; onArchiveProgress?.(100); return password; }
|
|
if (result.aborted) throw new Error("aborted:extract");
|
|
if (result.timedOut || result.missingCommand) break;
|
|
lastError = result.errorText;
|
|
}
|
|
}
|
|
|
|
throw withExtractionErrorHints(new Error(lastError || "Entpacken fehlgeschlagen"), { legacyBestPercent: bestPercent, legacyExtractor: extractorName });
|
|
}
|
|
|
|
async function runExternalExtract(
|
|
archivePath: string,
|
|
targetDir: string,
|
|
conflictMode: ConflictMode,
|
|
passwordCandidates: string[],
|
|
onArchiveProgress?: (percent: number) => void,
|
|
signal?: AbortSignal,
|
|
hybridMode = false,
|
|
onPasswordAttempt?: (attempt: number, total: number) => void,
|
|
forceFlatMode = false,
|
|
flatModeResult?: { needed: boolean },
|
|
onLog?: ExtractOptions["onLog"]
|
|
): Promise<string> {
|
|
const timeoutMs = await computeExtractTimeoutMs(archivePath);
|
|
const configuredBackendMode = extractorBackendMode();
|
|
const backendMode = extractorBackendModeForArchive(archivePath);
|
|
const archiveName = path.basename(archivePath);
|
|
const totalStartedAt = Date.now();
|
|
let jvmFailureReason = "";
|
|
let jvmCodecError = false;
|
|
let fallbackFromJvm = false;
|
|
logger.info(`Extract-Backend Start: archive=${archiveName}, mode=${backendMode}, configuredMode=${configuredBackendMode}, pwCandidates=${passwordCandidates.length}, timeoutMs=${timeoutMs}, hybrid=${hybridMode}`);
|
|
onLog?.("INFO", `Extract-Backend Start: archive=${archiveName}, mode=${backendMode}, configuredMode=${configuredBackendMode}, pwCandidates=${passwordCandidates.length}, timeoutMs=${timeoutMs}, hybrid=${hybridMode}`);
|
|
|
|
await fs.promises.mkdir(targetDir, { recursive: true });
|
|
|
|
let subst: SubstMapping | null = null;
|
|
|
|
try {
|
|
if (backendMode !== "legacy") {
|
|
const layout = resolveJvmExtractorLayout();
|
|
if (!layout) {
|
|
jvmFailureReason = NO_JVM_EXTRACTOR_MESSAGE;
|
|
if (backendMode === "jvm") {
|
|
throw new Error(NO_JVM_EXTRACTOR_MESSAGE);
|
|
}
|
|
logger.warn(`JVM-Extractor nicht verfügbar, nutze Legacy-Extractor: ${path.basename(archivePath)}`);
|
|
} else {
|
|
const emptyCount = passwordCandidates.filter((candidate) => candidate === "").length;
|
|
logger.info(`JVM-Extractor aktiv (${layout.rootDir}): ${archiveName}, passwordCount=${passwordCandidates.length}, redacted=true, emptyCandidates=${emptyCount}`);
|
|
const jvmStartedAt = Date.now();
|
|
onLog?.("INFO", `JVM-Extractor vorbereitet: archive=${archiveName}, passwordCandidates=${passwordCandidates.length}, layout=${layout.rootDir}`);
|
|
const jvmResult = await runJvmExtractCommand(
|
|
layout, archivePath, targetDir, conflictMode, passwordCandidates,
|
|
onArchiveProgress, signal, timeoutMs
|
|
);
|
|
const jvmMs = Date.now() - jvmStartedAt;
|
|
onLog?.("INFO", `JVM-Extractor Ergebnis: archive=${archiveName}, ok=${jvmResult.ok}, ms=${jvmMs}, timedOut=${jvmResult.timedOut}, aborted=${jvmResult.aborted}, backend=${jvmResult.backend || "unknown"}, usedPassword=${jvmResult.usedPassword ? "yes" : "no"}`);
|
|
logger.info(`JVM-Extractor Ergebnis: archive=${archiveName}, ok=${jvmResult.ok}, ms=${jvmMs}, timedOut=${jvmResult.timedOut}, aborted=${jvmResult.aborted}, backend=${jvmResult.backend || "unknown"}, usedPassword=${jvmResult.usedPassword ? "yes" : "no"}`);
|
|
|
|
if (jvmResult.ok) {
|
|
logger.info(`Entpackt via ${jvmResult.backend || "jvm"}: ${archiveName}`);
|
|
logger.info(`Extract-Backend Ende: archive=${archiveName}, backend=${jvmResult.backend || "jvm"}, mode=${backendMode}, ms=${Date.now() - totalStartedAt}, fallbackFromJvm=false, usedPassword=${jvmResult.usedPassword ? "yes" : "no"}`);
|
|
return jvmResult.usedPassword;
|
|
}
|
|
if (jvmResult.aborted) {
|
|
throw new Error("aborted:extract");
|
|
}
|
|
if (jvmResult.timedOut) {
|
|
throw new Error(jvmResult.errorText || `Entpacken Timeout nach ${Math.ceil(timeoutMs / 1000)}s`);
|
|
}
|
|
|
|
jvmFailureReason = jvmResult.errorText || "JVM-Extractor fehlgeschlagen";
|
|
fallbackFromJvm = true;
|
|
const jvmFailureLower = jvmFailureReason.toLowerCase();
|
|
const isUnsupportedMethod = jvmFailureReason.includes("UNSUPPORTEDMETHOD");
|
|
const isCodecError = jvmFailureLower.includes("registered codecs")
|
|
|| jvmFailureLower.includes("can not open")
|
|
|| jvmFailureLower.includes("cannot open archive");
|
|
jvmCodecError = isCodecError;
|
|
const isWrongPassword = jvmFailureReason.includes("WRONG_PASSWORD")
|
|
|| jvmFailureLower.includes("wrong password");
|
|
const shouldFallbackToLegacy = isUnsupportedMethod || isCodecError || isWrongPassword;
|
|
onLog?.("WARN", `JVM-Extractor Fallback-Analyse: archive=${archiveName}, unsupportedMethod=${isUnsupportedMethod}, codecError=${isCodecError}, wrongPassword=${isWrongPassword}, backendMode=${backendMode}`);
|
|
if (backendMode === "jvm" && !shouldFallbackToLegacy) {
|
|
throw new Error(jvmFailureReason);
|
|
}
|
|
if (isUnsupportedMethod) {
|
|
logger.warn(`JVM-Extractor: Komprimierungsmethode nicht unterstützt, fallback auf Legacy: ${path.basename(archivePath)}`);
|
|
} else if (isCodecError) {
|
|
logger.warn(`JVM-Extractor: Archiv-Format nicht erkannt, fallback auf Legacy: ${path.basename(archivePath)}`);
|
|
} else if (isWrongPassword) {
|
|
logger.warn(`JVM-Extractor: Kein Passwort hat funktioniert, fallback auf Legacy: ${path.basename(archivePath)}`);
|
|
} else {
|
|
logger.warn(`JVM-Extractor Fehler, fallback auf Legacy: ${jvmFailureReason}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
subst = createSubstMapping(targetDir);
|
|
const effectiveTargetDir = subst ? `${subst.drive}:\\` : targetDir;
|
|
if (subst) {
|
|
onLog?.("INFO", `Legacy-Zielpfad verkuerzt via subst: archive=${archiveName}, originalTargetDir=${targetDir}, effectiveTargetDir=${effectiveTargetDir}`);
|
|
} else {
|
|
onLog?.("INFO", `Legacy-Zielpfad unveraendert: archive=${archiveName}, effectiveTargetDir=${effectiveTargetDir}`);
|
|
}
|
|
|
|
const command = await resolveExtractorCommand(archivePath);
|
|
const legacyStartedAt = Date.now();
|
|
let password: string;
|
|
let usedCommand = command;
|
|
try {
|
|
try {
|
|
password = await runExternalExtractInner(
|
|
command, archivePath, effectiveTargetDir, conflictMode, passwordCandidates,
|
|
onArchiveProgress, signal, timeoutMs, hybridMode, onPasswordAttempt,
|
|
forceFlatMode, flatModeResult, onLog
|
|
);
|
|
} catch (primaryError) {
|
|
const isRar = /\.rar$/i.test(archiveName) || /\.r\d{2,3}$/i.test(archiveName);
|
|
const errText = String((primaryError as Error)?.message || primaryError || "");
|
|
const isPasswordOrCorrupt = /wrong.password|checksum error|corrupt/i.test(errText);
|
|
if (isRar && isPasswordOrCorrupt && !signal?.aborted) {
|
|
const alt = await findAlternativeExtractor(command, archivePath);
|
|
if (alt) {
|
|
const altName = path.basename(alt).replace(/\.exe$/i, "");
|
|
onLog?.("INFO", `Legacy-Fallback: primary=${path.basename(command)}, alternative=${altName}, archive=${archiveName}`);
|
|
logger.info(`Legacy-Fallback: ${path.basename(command)} fehlgeschlagen bei RAR, versuche ${altName}: ${archiveName}`);
|
|
usedCommand = alt;
|
|
password = await runExternalExtractInner(
|
|
alt, archivePath, effectiveTargetDir, conflictMode, passwordCandidates,
|
|
onArchiveProgress, signal, timeoutMs, hybridMode, onPasswordAttempt,
|
|
forceFlatMode, flatModeResult, onLog
|
|
);
|
|
} else {
|
|
throw primaryError;
|
|
}
|
|
} else {
|
|
throw primaryError;
|
|
}
|
|
}
|
|
} catch (legacyError) {
|
|
const initialLegacyText = String((legacyError as Error)?.message || legacyError || "");
|
|
const initialLegacyCategory = classifyExtractionError(initialLegacyText);
|
|
const initialLegacyHints = legacyError as ExtractionErrorWithHints;
|
|
const initialLegacyBestPercent = Number.isFinite(initialLegacyHints.legacyBestPercent)
|
|
? Number(initialLegacyHints.legacyBestPercent || 0)
|
|
: 0;
|
|
const isCrcOrWrongPw = initialLegacyCategory === "crc_error" || initialLegacyCategory === "wrong_password";
|
|
let finalLegacyError: Error;
|
|
|
|
if (isCrcOrWrongPw && !signal?.aborted) {
|
|
const retryDelayMs = 2500;
|
|
logger.warn(
|
|
`Legacy-Extraktion fehlgeschlagen (${initialLegacyCategory}), Retry nach ${retryDelayMs}ms Delay: ${archiveName}`
|
|
);
|
|
onLog?.("WARN", `Legacy-Extraktion fehlgeschlagen (${initialLegacyCategory}), Retry nach ${retryDelayMs}ms Delay: ${archiveName}`);
|
|
await extractRetryDelay(retryDelayMs);
|
|
if (!signal?.aborted) {
|
|
try {
|
|
const retryCmd = usedCommand;
|
|
const retryPassword = await runExternalExtractInner(
|
|
retryCmd,
|
|
archivePath,
|
|
effectiveTargetDir,
|
|
conflictMode,
|
|
passwordCandidates,
|
|
onArchiveProgress,
|
|
signal,
|
|
timeoutMs,
|
|
hybridMode,
|
|
onPasswordAttempt,
|
|
forceFlatMode,
|
|
flatModeResult,
|
|
onLog
|
|
);
|
|
logger.info(`Legacy-Retry erfolgreich: ${archiveName}`);
|
|
onLog?.("INFO", `Legacy-Retry erfolgreich: ${archiveName}`);
|
|
password = retryPassword;
|
|
usedCommand = retryCmd;
|
|
const retryExtractorName = path.basename(retryCmd).replace(/\.exe$/i, "");
|
|
const retryLegacyMs = Date.now() - legacyStartedAt;
|
|
if (jvmFailureReason) {
|
|
logger.info(`Entpackt via legacy/${retryExtractorName} (nach JVM-Fehler): ${archiveName}`);
|
|
} else {
|
|
logger.info(`Entpackt via legacy/${retryExtractorName} (nach Legacy-Retry): ${archiveName}`);
|
|
}
|
|
logger.info(`Extract-Backend Ende: archive=${archiveName}, backend=legacy/${retryExtractorName}, mode=${backendMode}, ms=${Date.now() - totalStartedAt}, legacyMs=${retryLegacyMs}, fallbackFromJvm=${fallbackFromJvm}, usedPassword=${password ? "yes" : "no"}`);
|
|
onLog?.("INFO", `Extract-Backend Ende: archive=${archiveName}, backend=legacy/${retryExtractorName}, mode=${backendMode}, ms=${Date.now() - totalStartedAt}, legacyMs=${retryLegacyMs}, fallbackFromJvm=${fallbackFromJvm}, usedPassword=${password ? "yes" : "no"}`);
|
|
return password;
|
|
} catch (retryError) {
|
|
const retryText = String((retryError as Error)?.message || retryError || "");
|
|
const retryCategory = classifyExtractionError(retryText);
|
|
logger.warn(`Legacy-Retry ebenfalls fehlgeschlagen (${retryCategory}): ${archiveName}`);
|
|
onLog?.("WARN", `Legacy-Retry ebenfalls fehlgeschlagen (${retryCategory}): ${archiveName}`);
|
|
const suggestRedownload = jvmCodecError && (retryCategory === "crc_error" || retryCategory === "wrong_password");
|
|
finalLegacyError = withExtractionErrorHints(retryError, {
|
|
suggestRedownload,
|
|
jvmFailureReason: jvmFailureReason || undefined
|
|
});
|
|
}
|
|
} else {
|
|
finalLegacyError = withExtractionErrorHints(legacyError, {
|
|
jvmFailureReason: jvmFailureReason || undefined
|
|
});
|
|
}
|
|
} else {
|
|
const suggestRedownload = jvmCodecError && isCrcOrWrongPw;
|
|
finalLegacyError = withExtractionErrorHints(legacyError, {
|
|
suggestRedownload,
|
|
jvmFailureReason: jvmFailureReason || undefined
|
|
});
|
|
}
|
|
|
|
const finalLegacyHints = finalLegacyError as ExtractionErrorWithHints;
|
|
const finalLegacyText = String(finalLegacyError?.message || finalLegacyError || "");
|
|
const finalLegacyBestPercent = Number.isFinite(finalLegacyHints.legacyBestPercent)
|
|
? Number(finalLegacyHints.legacyBestPercent || 0)
|
|
: initialLegacyBestPercent;
|
|
|
|
if (!signal?.aborted && shouldFallbackLegacyRarToJvm(archivePath, configuredBackendMode, backendMode, finalLegacyText, finalLegacyBestPercent)) {
|
|
const layout = resolveJvmExtractorLayout();
|
|
if (layout) {
|
|
logger.warn(`Legacy->JVM-Fallback: archive=${archiveName}, bestPercent=${finalLegacyBestPercent}, reason=${cleanErrorText(finalLegacyText)}`);
|
|
onLog?.("WARN", `Legacy->JVM-Fallback: archive=${archiveName}, bestPercent=${finalLegacyBestPercent}, reason=${cleanErrorText(finalLegacyText)}`);
|
|
const jvmStartedAt = Date.now();
|
|
const jvmResult = await runJvmExtractCommand(
|
|
layout,
|
|
archivePath,
|
|
targetDir,
|
|
conflictMode,
|
|
passwordCandidates,
|
|
onArchiveProgress,
|
|
signal,
|
|
timeoutMs
|
|
);
|
|
const jvmMs = Date.now() - jvmStartedAt;
|
|
logger.info(`JVM-Extractor Ergebnis (nach Legacy-Fallback): archive=${archiveName}, ok=${jvmResult.ok}, ms=${jvmMs}, timedOut=${jvmResult.timedOut}, aborted=${jvmResult.aborted}, backend=${jvmResult.backend || "unknown"}, usedPassword=${jvmResult.usedPassword ? "yes" : "no"}`);
|
|
onLog?.("INFO", `JVM-Extractor Ergebnis (nach Legacy-Fallback): archive=${archiveName}, ok=${jvmResult.ok}, ms=${jvmMs}, timedOut=${jvmResult.timedOut}, aborted=${jvmResult.aborted}, backend=${jvmResult.backend || "unknown"}, usedPassword=${jvmResult.usedPassword ? "yes" : "no"}`);
|
|
if (jvmResult.ok) {
|
|
logger.info(`Entpackt via ${jvmResult.backend || "jvm"} (nach Legacy-Fallback): ${archiveName}`);
|
|
logger.info(`Extract-Backend Ende: archive=${archiveName}, backend=${jvmResult.backend || "jvm"}, mode=${backendMode}, ms=${Date.now() - totalStartedAt}, fallbackFromJvm=${fallbackFromJvm}, fallbackFromLegacy=true, usedPassword=${jvmResult.usedPassword ? "yes" : "no"}`);
|
|
onLog?.("INFO", `Extract-Backend Ende: archive=${archiveName}, backend=${jvmResult.backend || "jvm"}, mode=${backendMode}, ms=${Date.now() - totalStartedAt}, fallbackFromJvm=${fallbackFromJvm}, fallbackFromLegacy=true, usedPassword=${jvmResult.usedPassword ? "yes" : "no"}`);
|
|
return jvmResult.usedPassword;
|
|
}
|
|
if (jvmResult.aborted) {
|
|
throw new Error("aborted:extract");
|
|
}
|
|
finalLegacyError = withExtractionErrorHints(finalLegacyError, {
|
|
jvmFailureReason: jvmResult.errorText || "JVM-Extractor fehlgeschlagen"
|
|
});
|
|
logger.warn(`Legacy->JVM-Fallback ebenfalls fehlgeschlagen: ${archiveName} (${cleanErrorText(jvmResult.errorText || "JVM-Extractor fehlgeschlagen")})`);
|
|
onLog?.("WARN", `Legacy->JVM-Fallback ebenfalls fehlgeschlagen: archive=${archiveName}, error=${cleanErrorText(jvmResult.errorText || "JVM-Extractor fehlgeschlagen")}`);
|
|
} else {
|
|
logger.warn(`Legacy->JVM-Fallback uebersprungen: JVM-Extractor nicht verfuegbar fuer ${archiveName}`);
|
|
onLog?.("WARN", `Legacy->JVM-Fallback uebersprungen: archive=${archiveName}, reason=no_jvm_extractor`);
|
|
}
|
|
}
|
|
|
|
throw finalLegacyError;
|
|
}
|
|
const legacyMs = Date.now() - legacyStartedAt;
|
|
const extractorName = path.basename(usedCommand).replace(/\.exe$/i, "");
|
|
if (jvmFailureReason) {
|
|
logger.info(`Entpackt via legacy/${extractorName} (nach JVM-Fehler): ${archiveName}`);
|
|
} else {
|
|
logger.info(`Entpackt via legacy/${extractorName}: ${archiveName}`);
|
|
}
|
|
logger.info(`Extract-Backend Ende: archive=${archiveName}, backend=legacy/${extractorName}, mode=${backendMode}, ms=${Date.now() - totalStartedAt}, legacyMs=${legacyMs}, fallbackFromJvm=${fallbackFromJvm}, usedPassword=${password ? "yes" : "no"}`);
|
|
onLog?.("INFO", `Extract-Backend Ende: archive=${archiveName}, backend=legacy/${extractorName}, mode=${backendMode}, ms=${Date.now() - totalStartedAt}, legacyMs=${legacyMs}, fallbackFromJvm=${fallbackFromJvm}, usedPassword=${password ? "yes" : "no"}`);
|
|
return password;
|
|
} finally {
|
|
if (subst) removeSubstMapping(subst);
|
|
}
|
|
}
|
|
|
|
function isZipSafetyGuardError(error: unknown): boolean {
|
|
const text = String(error || "").toLowerCase();
|
|
return text.includes("path traversal")
|
|
|| text.includes("zip-eintrag verdächtig groß")
|
|
|| text.includes("zip-eintrag verdaechtig gross");
|
|
}
|
|
|
|
function isZipInternalLimitError(error: unknown): boolean {
|
|
const text = String(error || "").toLowerCase();
|
|
return text.includes("zip-eintrag zu groß")
|
|
|| text.includes("zip-eintrag komprimiert zu groß")
|
|
|| text.includes("zip-eintrag ohne sichere groessenangabe");
|
|
}
|
|
|
|
function shouldFallbackToExternalZip(error: unknown): boolean {
|
|
if (isZipSafetyGuardError(error)) {
|
|
return false;
|
|
}
|
|
if (isZipInternalLimitError(error)) {
|
|
return true;
|
|
}
|
|
const text = String(error || "").toLowerCase();
|
|
if (text.includes("aborted:extract") || text.includes("extract_aborted")) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
async function extractZipArchive(archivePath: string, targetDir: string, conflictMode: ConflictMode, signal?: AbortSignal): Promise<void> {
|
|
const mode = effectiveConflictMode(conflictMode);
|
|
const memoryLimitBytes = zipEntryMemoryLimitBytes();
|
|
const zip = new AdmZip(archivePath);
|
|
const entries = zip.getEntries();
|
|
const resolvedTarget = path.resolve(targetDir);
|
|
const usedOutputs = new Set<string>();
|
|
const renameCounters = new Map<string, number>();
|
|
|
|
for (const entry of entries) {
|
|
if (signal?.aborted) {
|
|
throw new Error("aborted:extract");
|
|
}
|
|
const baseOutputPath = path.resolve(targetDir, entry.entryName);
|
|
if (!baseOutputPath.startsWith(resolvedTarget + path.sep) && baseOutputPath !== resolvedTarget) {
|
|
logger.warn(`ZIP-Eintrag übersprungen (Path Traversal): ${entry.entryName}`);
|
|
continue;
|
|
}
|
|
if (entry.isDirectory) {
|
|
await fs.promises.mkdir(baseOutputPath, { recursive: true });
|
|
continue;
|
|
}
|
|
|
|
const header = (entry as unknown as {
|
|
header?: {
|
|
size?: number;
|
|
compressedSize?: number;
|
|
crc?: number;
|
|
dataHeader?: {
|
|
size?: number;
|
|
compressedSize?: number;
|
|
crc?: number;
|
|
};
|
|
};
|
|
}).header;
|
|
const uncompressedSize = Number(header?.size ?? header?.dataHeader?.size ?? NaN);
|
|
const compressedSize = Number(header?.compressedSize ?? header?.dataHeader?.compressedSize ?? NaN);
|
|
|
|
if (!Number.isFinite(uncompressedSize) || uncompressedSize < 0) {
|
|
throw new Error("ZIP-Eintrag ohne sichere Groessenangabe fur internen Entpacker");
|
|
}
|
|
if (!Number.isFinite(compressedSize) || compressedSize < 0) {
|
|
throw new Error("ZIP-Eintrag ohne sichere Groessenangabe fur internen Entpacker");
|
|
}
|
|
|
|
if (uncompressedSize > memoryLimitBytes) {
|
|
const entryMb = Math.ceil(uncompressedSize / (1024 * 1024));
|
|
const limitMb = Math.ceil(memoryLimitBytes / (1024 * 1024));
|
|
throw new Error(`ZIP-Eintrag zu groß für internen Entpacker (${entryMb} MB > ${limitMb} MB)`);
|
|
}
|
|
if (compressedSize > memoryLimitBytes) {
|
|
const entryMb = Math.ceil(compressedSize / (1024 * 1024));
|
|
const limitMb = Math.ceil(memoryLimitBytes / (1024 * 1024));
|
|
throw new Error(`ZIP-Eintrag komprimiert zu groß für internen Entpacker (${entryMb} MB > ${limitMb} MB)`);
|
|
}
|
|
|
|
let outputPath = baseOutputPath;
|
|
let outputKey = pathSetKey(outputPath);
|
|
|
|
await fs.promises.mkdir(path.dirname(outputPath), { recursive: true });
|
|
const outputExists = usedOutputs.has(outputKey) || await fs.promises.access(outputPath).then(() => true, () => false);
|
|
if (outputExists) {
|
|
if (mode === "skip") {
|
|
continue;
|
|
}
|
|
if (mode === "rename") {
|
|
const parsed = path.parse(baseOutputPath);
|
|
const counterKey = pathSetKey(baseOutputPath);
|
|
let n = renameCounters.get(counterKey) || 1;
|
|
let candidate = baseOutputPath;
|
|
let candidateKey = outputKey;
|
|
while (n <= 10000) {
|
|
candidate = path.join(parsed.dir, `${parsed.name} (${n})${parsed.ext}`);
|
|
candidateKey = pathSetKey(candidate);
|
|
if (!usedOutputs.has(candidateKey) && !(await fs.promises.access(candidate).then(() => true, () => false))) {
|
|
break;
|
|
}
|
|
n += 1;
|
|
}
|
|
if (n > 10000) {
|
|
throw new Error(`ZIP-Rename-Limit erreicht für ${entry.entryName}`);
|
|
}
|
|
renameCounters.set(counterKey, n + 1);
|
|
if (signal?.aborted) {
|
|
throw new Error("aborted:extract");
|
|
}
|
|
outputPath = candidate;
|
|
outputKey = candidateKey;
|
|
}
|
|
}
|
|
|
|
if (signal?.aborted) {
|
|
throw new Error("aborted:extract");
|
|
}
|
|
const data = entry.getData();
|
|
if (data.length > memoryLimitBytes) {
|
|
const entryMb = Math.ceil(data.length / (1024 * 1024));
|
|
const limitMb = Math.ceil(memoryLimitBytes / (1024 * 1024));
|
|
throw new Error(`ZIP-Eintrag zu groß für internen Entpacker (${entryMb} MB > ${limitMb} MB)`);
|
|
}
|
|
const maxDeclaredSize = Math.max(uncompressedSize, compressedSize);
|
|
if (maxDeclaredSize > 0 && data.length > maxDeclaredSize * 20) {
|
|
throw new Error(`ZIP-Eintrag verdächtig groß nach Entpacken (${entry.entryName})`);
|
|
}
|
|
await fs.promises.writeFile(outputPath, data);
|
|
usedOutputs.add(outputKey);
|
|
}
|
|
}
|
|
|
|
async function estimateArchivesTotalBytes(candidates: string[]): Promise<number> {
|
|
let total = 0;
|
|
for (const archivePath of candidates) {
|
|
const parts = collectArchiveCleanupTargets(archivePath);
|
|
for (const part of parts) {
|
|
try {
|
|
total += (await fs.promises.stat(part)).size;
|
|
} catch { }
|
|
}
|
|
}
|
|
return total;
|
|
}
|
|
|
|
function humanSizeGB(bytes: number): string {
|
|
if (bytes >= 1024 * 1024 * 1024) {
|
|
return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
|
|
}
|
|
return `${(bytes / (1024 * 1024)).toFixed(0)} MB`;
|
|
}
|
|
|
|
async function checkDiskSpaceForExtraction(targetDir: string, candidates: string[]): Promise<void> {
|
|
if (candidates.length === 0) return;
|
|
const archiveBytes = await estimateArchivesTotalBytes(candidates);
|
|
if (archiveBytes <= 0) return;
|
|
const requiredBytes = Math.ceil(archiveBytes * DISK_SPACE_SAFETY_FACTOR);
|
|
|
|
let freeBytes: number;
|
|
try {
|
|
const stats = await fs.promises.statfs(targetDir);
|
|
freeBytes = stats.bfree * stats.bsize;
|
|
} catch {
|
|
return;
|
|
}
|
|
|
|
if (freeBytes < requiredBytes) {
|
|
const msg = `Nicht genug Speicherplatz: ${humanSizeGB(requiredBytes)} benötigt, ${humanSizeGB(freeBytes)} frei`;
|
|
logger.error(`Disk-Space-Check: ${msg} (target=${targetDir})`);
|
|
throw new Error(msg);
|
|
}
|
|
logger.info(`Disk-Space-Check OK: ${humanSizeGB(freeBytes)} frei, ${humanSizeGB(requiredBytes)} benötigt (target=${targetDir})`);
|
|
}
|
|
|
|
function zipEntryMemoryLimitBytes(): number {
|
|
const fromEnvMb = Number(process.env.RD_ZIP_ENTRY_MEMORY_LIMIT_MB ?? NaN);
|
|
if (Number.isFinite(fromEnvMb) && fromEnvMb >= 8 && fromEnvMb <= 4096) {
|
|
return Math.floor(fromEnvMb * 1024 * 1024);
|
|
}
|
|
return DEFAULT_ZIP_ENTRY_MEMORY_LIMIT_MB * 1024 * 1024;
|
|
}
|
|
|
|
async function shouldPreferExternalZip(archivePath: string): Promise<boolean> {
|
|
if (extractorBackendMode() !== "legacy") {
|
|
return true;
|
|
}
|
|
try {
|
|
const stat = await fs.promises.stat(archivePath);
|
|
return stat.size >= 64 * 1024 * 1024;
|
|
} catch {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
async function computeExtractTimeoutMs(archivePath: string): Promise<number> {
|
|
try {
|
|
const relatedFiles = collectArchiveCleanupTargets(archivePath);
|
|
let totalBytes = 0;
|
|
for (const filePath of relatedFiles) {
|
|
try {
|
|
totalBytes += (await fs.promises.stat(filePath)).size;
|
|
} catch {
|
|
}
|
|
}
|
|
if (totalBytes <= 0) {
|
|
totalBytes = (await fs.promises.stat(archivePath)).size;
|
|
}
|
|
const gib = totalBytes / (1024 * 1024 * 1024);
|
|
const dynamicMs = EXTRACT_BASE_TIMEOUT_MS + Math.floor(gib * EXTRACT_PER_GIB_TIMEOUT_MS);
|
|
return Math.max(EXTRACT_BASE_TIMEOUT_MS, Math.min(EXTRACT_MAX_TIMEOUT_MS, dynamicMs));
|
|
} catch {
|
|
return EXTRACT_BASE_TIMEOUT_MS;
|
|
}
|
|
}
|
|
|
|
function extractProgressFilePath(packageDir: string, packageId?: string): string {
|
|
if (packageId) {
|
|
return path.join(packageDir, `.rd_extract_progress_${packageId}.json`);
|
|
}
|
|
return path.join(packageDir, EXTRACT_PROGRESS_FILE);
|
|
}
|
|
|
|
async function readExtractResumeState(packageDir: string, packageId?: string): Promise<Set<string>> {
|
|
const progressPath = extractProgressFilePath(packageDir, packageId);
|
|
try {
|
|
await fs.promises.access(progressPath);
|
|
} catch {
|
|
return new Set<string>();
|
|
}
|
|
try {
|
|
const payload = JSON.parse(await fs.promises.readFile(progressPath, "utf8")) as Partial<ExtractResumeState>;
|
|
const names = Array.isArray(payload.completedArchives) ? payload.completedArchives : [];
|
|
return new Set(names.map((value) => archiveNameKey(String(value || "").trim())).filter(Boolean));
|
|
} catch {
|
|
return new Set<string>();
|
|
}
|
|
}
|
|
|
|
async function writeExtractResumeState(packageDir: string, completedArchives: Set<string>, packageId?: string): Promise<void> {
|
|
try {
|
|
await fs.promises.mkdir(packageDir, { recursive: true });
|
|
const progressPath = extractProgressFilePath(packageDir, packageId);
|
|
const payload: ExtractResumeState = {
|
|
completedArchives: Array.from(completedArchives)
|
|
.map((name) => archiveNameKey(name))
|
|
.sort((a, b) => a.localeCompare(b))
|
|
};
|
|
const tmpPath = progressPath + "." + Date.now() + "." + Math.random().toString(36).slice(2, 8) + ".tmp";
|
|
await fs.promises.writeFile(tmpPath, JSON.stringify(payload, null, 2), "utf8");
|
|
await fs.promises.rename(tmpPath, progressPath).catch(async () => {
|
|
await fs.promises.rm(tmpPath, { force: true }).catch(() => {});
|
|
});
|
|
} catch (error) {
|
|
logger.warn(`ExtractResumeState schreiben fehlgeschlagen: ${String(error)}`);
|
|
}
|
|
}
|
|
|
|
export async function clearExtractResumeState(packageDir: string, packageId?: string): Promise<void> {
|
|
try {
|
|
await fs.promises.rm(extractProgressFilePath(packageDir, packageId), { force: true });
|
|
} catch {
|
|
}
|
|
}
|
|
|
|
function emitExtractLog(
|
|
onLog: ExtractOptions["onLog"] | undefined,
|
|
level: "INFO" | "WARN" | "ERROR",
|
|
message: string
|
|
): void {
|
|
if (level === "INFO") {
|
|
logger.info(message);
|
|
} else if (level === "WARN") {
|
|
logger.warn(message);
|
|
} else {
|
|
logger.error(message);
|
|
}
|
|
onLog?.(level, message);
|
|
}
|
|
|
|
function effectiveConflictMode(conflictMode: ConflictMode): "overwrite" | "skip" | "rename" {
|
|
if (conflictMode === "rename") {
|
|
return "rename";
|
|
}
|
|
if (conflictMode === "overwrite") {
|
|
return "overwrite";
|
|
}
|
|
return "skip";
|
|
}
|
|
|
|
export async function extractPackageArchives(options: ExtractOptions): Promise<{ extracted: number; failed: number; lastError: string }> {
|
|
if (options.signal?.aborted) {
|
|
throw new Error("aborted:extract");
|
|
}
|
|
options.onProgress?.({ current: 0, total: 0, percent: 0, archiveName: "Archive scannen...", phase: "preparing" });
|
|
const allCandidates = await findArchiveCandidates(options.packageDir);
|
|
const candidates = options.onlyArchives
|
|
? allCandidates.filter((archivePath) => {
|
|
const key = process.platform === "win32" ? path.resolve(archivePath).toLowerCase() : path.resolve(archivePath);
|
|
return options.onlyArchives!.has(key);
|
|
})
|
|
: allCandidates;
|
|
logger.info(`Entpacken gestartet: packageDir=${options.packageDir}, targetDir=${options.targetDir}, archives=${candidates.length}${options.onlyArchives ? ` (hybrid, gesamt=${allCandidates.length})` : ""}, cleanupMode=${options.cleanupMode}, conflictMode=${options.conflictMode}`);
|
|
options.onLog?.("INFO", `Entpacken gestartet: packageDir=${options.packageDir}, targetDir=${options.targetDir}, archives=${candidates.length}${options.onlyArchives ? ` (hybrid, gesamt=${allCandidates.length})` : ""}, cleanupMode=${options.cleanupMode}, conflictMode=${options.conflictMode}`);
|
|
|
|
if (candidates.length > 0) {
|
|
options.onProgress?.({ current: 0, total: candidates.length, percent: 0, archiveName: "Speicherplatz prüfen...", phase: "preparing" });
|
|
try {
|
|
await fs.promises.mkdir(options.targetDir, { recursive: true });
|
|
} catch { }
|
|
await checkDiskSpaceForExtraction(options.targetDir, candidates);
|
|
}
|
|
|
|
if (candidates.length === 0) {
|
|
if (!options.onlyArchives) {
|
|
const existingResume = await readExtractResumeState(options.packageDir, options.packageId);
|
|
if (existingResume.size > 0 && await hasAnyEntries(options.targetDir)) {
|
|
await clearExtractResumeState(options.packageDir, options.packageId);
|
|
logger.info(`Entpacken übersprungen (Archive bereinigt, Ziel hat Dateien): ${options.packageDir}`);
|
|
options.onProgress?.({
|
|
current: existingResume.size,
|
|
total: existingResume.size,
|
|
percent: 100,
|
|
archiveName: "",
|
|
phase: "done"
|
|
});
|
|
return { extracted: existingResume.size, failed: 0, lastError: "" };
|
|
}
|
|
await clearExtractResumeState(options.packageDir, options.packageId);
|
|
}
|
|
logger.info(`Entpacken übersprungen (keine Archive gefunden): ${options.packageDir}`);
|
|
return { extracted: 0, failed: 0, lastError: "" };
|
|
}
|
|
|
|
const conflictMode = effectiveConflictMode(options.conflictMode);
|
|
if (options.conflictMode === "ask") {
|
|
logger.warn("Extract-ConflictMode 'ask' wird ohne Prompt als 'skip' behandelt");
|
|
}
|
|
const passwordCacheKey = packagePasswordCacheKey(options.packageDir, options.packageId);
|
|
const passwordCacheLabel = packagePasswordCacheLabel(options.packageDir, options.packageId);
|
|
let passwordCandidates = archivePasswords(options.passwordList || "");
|
|
const cachedPackagePassword = readCachedPackagePassword(passwordCacheKey);
|
|
if (cachedPackagePassword) {
|
|
passwordCandidates = prioritizePassword(passwordCandidates, cachedPackagePassword);
|
|
logger.info(`Passwort-Cache Treffer: ${passwordCacheLabel}, bekanntes Passwort wird zuerst getestet`);
|
|
options.onLog?.("INFO", `Passwort-Cache Treffer: ${passwordCacheLabel}, bekanntes Passwort wird zuerst getestet`);
|
|
}
|
|
const resumeCompleted = await readExtractResumeState(options.packageDir, options.packageId);
|
|
const resumeCompletedAtStart = resumeCompleted.size;
|
|
const allCandidateNames = new Set(allCandidates.map((archivePath) => archiveNameKey(path.basename(archivePath))));
|
|
for (const archiveName of Array.from(resumeCompleted.values())) {
|
|
if (!allCandidateNames.has(archiveName)) {
|
|
resumeCompleted.delete(archiveName);
|
|
}
|
|
}
|
|
if (resumeCompleted.size > 0) {
|
|
await writeExtractResumeState(options.packageDir, resumeCompleted, options.packageId);
|
|
} else {
|
|
await clearExtractResumeState(options.packageDir, options.packageId);
|
|
}
|
|
|
|
const pendingCandidates = candidates.filter((archivePath) => !resumeCompleted.has(archiveNameKey(path.basename(archivePath))));
|
|
let extracted = candidates.length - pendingCandidates.length;
|
|
let failed = 0;
|
|
let lastError = "";
|
|
let learnedPassword = cachedPackagePassword;
|
|
let packageNeedsFlatMode = false;
|
|
const extractedArchives = new Set<string>();
|
|
const failedArchiveCategories = new Map<string, ExtractErrorCategory>();
|
|
for (const archivePath of candidates) {
|
|
if (resumeCompleted.has(archiveNameKey(path.basename(archivePath)))) {
|
|
extractedArchives.add(archivePath);
|
|
}
|
|
}
|
|
|
|
const rememberLearnedPassword = (password: string): void => {
|
|
const normalized = String(password || "").trim();
|
|
if (!normalized) {
|
|
return;
|
|
}
|
|
const changed = normalized !== learnedPassword;
|
|
learnedPassword = normalized;
|
|
passwordCandidates = prioritizePassword(passwordCandidates, normalized);
|
|
writeCachedPackagePassword(passwordCacheKey, normalized);
|
|
if (changed) {
|
|
logger.info(`Passwort-Cache Update: ${passwordCacheLabel}, neues Passwort gelernt`);
|
|
options.onLog?.("INFO", `Passwort-Cache Update: ${passwordCacheLabel}, neues Passwort gelernt`);
|
|
}
|
|
};
|
|
|
|
const emitProgress = (
|
|
current: number,
|
|
archiveName: string,
|
|
phase: "extracting" | "done",
|
|
archivePercent?: number,
|
|
elapsedMs?: number,
|
|
pwInfo?: { passwordAttempt?: number; passwordTotal?: number; passwordFound?: boolean },
|
|
archiveInfo?: { archiveDone?: boolean; archiveSuccess?: boolean }
|
|
): void => {
|
|
if (!options.onProgress) {
|
|
return;
|
|
}
|
|
const total = Math.max(1, candidates.length);
|
|
let percent = Math.max(0, Math.min(100, Math.floor((current / total) * 100)));
|
|
let normalizedArchivePercent = Math.max(0, Math.min(100, Number(archivePercent ?? 0)));
|
|
if (phase !== "done") {
|
|
const boundedCurrent = Math.max(0, Math.min(total, current));
|
|
if (archiveInfo?.archiveDone !== true && normalizedArchivePercent >= 100) {
|
|
normalizedArchivePercent = 99;
|
|
}
|
|
percent = Math.max(0, Math.min(100, Math.floor(((boundedCurrent + (normalizedArchivePercent / 100)) / total) * 100)));
|
|
}
|
|
try {
|
|
options.onProgress({
|
|
current,
|
|
total,
|
|
percent,
|
|
archiveName,
|
|
archivePercent: normalizedArchivePercent,
|
|
elapsedMs,
|
|
phase,
|
|
...(archiveInfo || {}),
|
|
...(pwInfo || {})
|
|
});
|
|
} catch (error) {
|
|
logger.warn(`onProgress callback Fehler unterdrückt: ${cleanErrorText(String(error))}`);
|
|
}
|
|
};
|
|
|
|
emitProgress(extracted, "", "extracting");
|
|
|
|
for (const archivePath of candidates) {
|
|
if (resumeCompleted.has(archiveNameKey(path.basename(archivePath)))) {
|
|
emitProgress(extracted, path.basename(archivePath), "extracting", 100, 0, undefined, { archiveDone: true, archiveSuccess: true });
|
|
}
|
|
}
|
|
|
|
const maxParallel = Math.max(1, options.maxParallel || 1);
|
|
let noExtractorEncountered = false;
|
|
let lastArchiveFinishedAt: number | null = null;
|
|
|
|
const extractSingleArchive = async (archivePath: string): Promise<void> => {
|
|
if (options.signal?.aborted) {
|
|
throw new Error("aborted:extract");
|
|
}
|
|
if (noExtractorEncountered) {
|
|
throw new Error("noextractor:skipped");
|
|
}
|
|
const archiveName = path.basename(archivePath);
|
|
const archiveResumeKey = archiveNameKey(archiveName);
|
|
const archiveStartedAt = Date.now();
|
|
const startedCurrent = extracted + failed;
|
|
if (lastArchiveFinishedAt !== null) {
|
|
logger.info(`Extract-Trace Gap: before=${archiveName}, prevDoneToStartMs=${archiveStartedAt - lastArchiveFinishedAt}, progress=${startedCurrent}/${candidates.length}`);
|
|
}
|
|
let archivePercent = 0;
|
|
let reached99At: number | null = null;
|
|
let archiveOutcome: "success" | "failed" | "skipped" = "failed";
|
|
emitProgress(extracted + failed, archiveName, "extracting", archivePercent, 0);
|
|
const pulseTimer = setInterval(() => {
|
|
emitProgress(extracted + failed, archiveName, "extracting", archivePercent, Date.now() - archiveStartedAt);
|
|
}, 1100);
|
|
const hybrid = Boolean(options.hybridMode);
|
|
const filenamePasswords = archiveFilenamePasswords(archiveName);
|
|
const nonEmptyBasePasswords = passwordCandidates.filter((p) => p !== "");
|
|
const orderedNonEmpty = learnedPassword
|
|
? [learnedPassword, ...nonEmptyBasePasswords.filter((p) => p !== learnedPassword), ...filenamePasswords]
|
|
: [...filenamePasswords, ...nonEmptyBasePasswords];
|
|
const archivePasswordCandidates = learnedPassword
|
|
? Array.from(new Set([...orderedNonEmpty, ""]))
|
|
: Array.from(new Set(["", ...orderedNonEmpty]));
|
|
const reportArchiveProgress = (value: number): void => {
|
|
archivePercent = nextArchivePercent(archivePercent, value);
|
|
if (reached99At === null && archivePercent >= 99) {
|
|
reached99At = Date.now();
|
|
logger.info(`Extract-Trace 99%: archive=${archiveName}, elapsedMs=${reached99At - archiveStartedAt}`);
|
|
}
|
|
emitProgress(extracted + failed, archiveName, "extracting", archivePercent, Date.now() - archiveStartedAt);
|
|
};
|
|
|
|
const isGenericSplit = /\.\d{3}$/i.test(archiveName) && !/\.(zip|7z)\.\d{3}$/i.test(archiveName);
|
|
if (isGenericSplit) {
|
|
const sig = await detectArchiveSignature(archivePath);
|
|
if (!sig) {
|
|
logger.info(`Generische Split-Datei übersprungen (keine Archiv-Signatur): ${archiveName}`);
|
|
extracted += 1;
|
|
resumeCompleted.add(archiveResumeKey);
|
|
extractedArchives.add(archivePath);
|
|
await writeExtractResumeState(options.packageDir, resumeCompleted, options.packageId);
|
|
clearInterval(pulseTimer);
|
|
archiveOutcome = "skipped";
|
|
const skippedAt = Date.now();
|
|
lastArchiveFinishedAt = skippedAt;
|
|
logger.info(`Extract-Trace Archiv Übersprungen: archive=${archiveName}, ms=${skippedAt - archiveStartedAt}, reason=no-signature`);
|
|
return;
|
|
}
|
|
logger.info(`Generische Split-Datei verifiziert (Signatur: ${sig}): ${archiveName}`);
|
|
}
|
|
|
|
logger.info(`Entpacke Archiv: ${path.basename(archivePath)} -> ${options.targetDir}${hybrid ? " (hybrid, reduced threads, low I/O)" : ""}`);
|
|
options.onLog?.("INFO", `Entpacke Archiv: ${path.basename(archivePath)} -> ${options.targetDir}${hybrid ? " (hybrid, reduced threads, low I/O)" : ""}`);
|
|
const emptyArchivePasswordCount = archivePasswordCandidates.filter((candidate) => candidate === "").length;
|
|
options.onLog?.("INFO", `Archiv-Passwortliste: archive=${archiveName}, passwordCount=${archivePasswordCandidates.length}, redacted=true, emptyCandidates=${emptyArchivePasswordCount}`);
|
|
const hasManyPasswords = archivePasswordCandidates.length > 1;
|
|
if (hasManyPasswords) {
|
|
emitProgress(extracted + failed, archiveName, "extracting", 0, 0, { passwordAttempt: 0, passwordTotal: archivePasswordCandidates.length });
|
|
}
|
|
const onPwAttempt = hasManyPasswords
|
|
? (attempt: number, total: number) => {
|
|
emitProgress(extracted + failed, archiveName, "extracting", archivePercent, Date.now() - archiveStartedAt, { passwordAttempt: attempt, passwordTotal: total });
|
|
options.onLog?.("INFO", `Passwort-Versuch ${attempt}/${total}: archive=${archiveName}, password=<redacted>`);
|
|
}
|
|
: undefined;
|
|
try {
|
|
currentExtractCpuPriority = options.extractCpuPriority;
|
|
const ext = path.extname(archivePath).toLowerCase();
|
|
if (ext === ".zip") {
|
|
const preferExternal = await shouldPreferExternalZip(archivePath);
|
|
if (preferExternal) {
|
|
try {
|
|
const usedPassword = await runExternalExtract(archivePath, options.targetDir, options.conflictMode, archivePasswordCandidates, (value) => {
|
|
reportArchiveProgress(value);
|
|
}, options.signal, hybrid, onPwAttempt, false, undefined, options.onLog);
|
|
rememberLearnedPassword(usedPassword);
|
|
} catch (error) {
|
|
if (isNoExtractorError(String(error))) {
|
|
await extractZipArchive(archivePath, options.targetDir, options.conflictMode, options.signal);
|
|
} else {
|
|
throw error;
|
|
}
|
|
}
|
|
} else {
|
|
try {
|
|
await extractZipArchive(archivePath, options.targetDir, options.conflictMode, options.signal);
|
|
archivePercent = 100;
|
|
} catch (error) {
|
|
if (!shouldFallbackToExternalZip(error)) {
|
|
throw error;
|
|
}
|
|
try {
|
|
const usedPassword = await runExternalExtract(archivePath, options.targetDir, options.conflictMode, archivePasswordCandidates, (value) => {
|
|
reportArchiveProgress(value);
|
|
}, options.signal, hybrid, onPwAttempt, false, undefined, options.onLog);
|
|
rememberLearnedPassword(usedPassword);
|
|
} catch (externalError) {
|
|
if (isNoExtractorError(String(externalError)) || isUnsupportedArchiveFormatError(String(externalError))) {
|
|
throw error;
|
|
}
|
|
throw externalError;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
const flatResult = { needed: false };
|
|
const usedPassword = await runExternalExtract(archivePath, options.targetDir, options.conflictMode, archivePasswordCandidates, (value) => {
|
|
reportArchiveProgress(value);
|
|
}, options.signal, hybrid, onPwAttempt, packageNeedsFlatMode, flatResult, options.onLog);
|
|
rememberLearnedPassword(usedPassword);
|
|
if (flatResult.needed) packageNeedsFlatMode = true;
|
|
}
|
|
extracted += 1;
|
|
extractedArchives.add(archivePath);
|
|
failedArchiveCategories.delete(archivePath);
|
|
resumeCompleted.add(archiveResumeKey);
|
|
await writeExtractResumeState(options.packageDir, resumeCompleted, options.packageId);
|
|
logger.info(`Entpacken erfolgreich: ${path.basename(archivePath)}`);
|
|
options.onLog?.("INFO", `Entpacken erfolgreich: ${path.basename(archivePath)}`);
|
|
archiveOutcome = "success";
|
|
const successAt = Date.now();
|
|
const tailAfter99Ms = reached99At ? (successAt - reached99At) : -1;
|
|
logger.info(`Extract-Trace Archiv Erfolg: archive=${archiveName}, totalMs=${successAt - archiveStartedAt}, tailAfter99Ms=${tailAfter99Ms >= 0 ? tailAfter99Ms : "n/a"}, pwCandidates=${archivePasswordCandidates.length}`);
|
|
lastArchiveFinishedAt = successAt;
|
|
archivePercent = 100;
|
|
if (hasManyPasswords) {
|
|
emitProgress(extracted + failed, archiveName, "extracting", archivePercent, Date.now() - archiveStartedAt, { passwordFound: true }, { archiveDone: true, archiveSuccess: true });
|
|
} else {
|
|
emitProgress(extracted + failed, archiveName, "extracting", archivePercent, Date.now() - archiveStartedAt, undefined, { archiveDone: true, archiveSuccess: true });
|
|
}
|
|
} catch (error) {
|
|
const errorText = String(error);
|
|
if (isExtractAbortError(errorText)) {
|
|
throw error;
|
|
}
|
|
failed += 1;
|
|
lastError = errorText;
|
|
const errorCategory = classifyExtractionError(errorText);
|
|
failedArchiveCategories.set(archivePath, errorCategory);
|
|
const hintedError = error as ExtractionErrorWithHints;
|
|
options.onArchiveFailure?.({
|
|
archiveName,
|
|
errorText,
|
|
category: errorCategory,
|
|
suggestRedownload: hintedError?.suggestRedownload === true,
|
|
jvmFailureReason: hintedError?.jvmFailureReason
|
|
});
|
|
logger.error(`Entpack-Fehler ${path.basename(archivePath)} [${errorCategory}]: ${errorText}`);
|
|
options.onLog?.("ERROR", `Entpack-Fehler ${path.basename(archivePath)} [${errorCategory}]: ${errorText}`);
|
|
if (errorCategory === "wrong_password" && learnedPassword) {
|
|
learnedPassword = "";
|
|
clearCachedPackagePassword(passwordCacheKey);
|
|
logger.warn(`Passwort-Cache verworfen: ${passwordCacheLabel} (wrong_password)`);
|
|
options.onLog?.("WARN", `Passwort-Cache verworfen: ${passwordCacheLabel} (wrong_password)`);
|
|
}
|
|
const failedAt = Date.now();
|
|
const tailAfter99Ms = reached99At ? (failedAt - reached99At) : -1;
|
|
logger.warn(`Extract-Trace Archiv Fehler: archive=${archiveName}, totalMs=${failedAt - archiveStartedAt}, tailAfter99Ms=${tailAfter99Ms >= 0 ? tailAfter99Ms : "n/a"}, category=${errorCategory}`);
|
|
lastArchiveFinishedAt = failedAt;
|
|
emitProgress(extracted + failed, archiveName, "extracting", archivePercent, Date.now() - archiveStartedAt, undefined, { archiveDone: true, archiveSuccess: false });
|
|
if (isNoExtractorError(errorText)) {
|
|
noExtractorEncountered = true;
|
|
}
|
|
} finally {
|
|
clearInterval(pulseTimer);
|
|
if (lastArchiveFinishedAt === null || lastArchiveFinishedAt < archiveStartedAt) {
|
|
lastArchiveFinishedAt = Date.now();
|
|
}
|
|
logger.info(`Extract-Trace Archiv Ende: archive=${archiveName}, outcome=${archiveOutcome}, elapsedMs=${lastArchiveFinishedAt - archiveStartedAt}, percent=${archivePercent}`);
|
|
}
|
|
};
|
|
|
|
if (maxParallel <= 1) {
|
|
for (const archivePath of pendingCandidates) {
|
|
if (options.signal?.aborted || noExtractorEncountered) break;
|
|
await extractSingleArchive(archivePath);
|
|
}
|
|
if (noExtractorEncountered) {
|
|
const remaining = candidates.length - (extracted + failed);
|
|
if (remaining > 0) {
|
|
failed += remaining;
|
|
emitProgress(candidates.length, "", "extracting", 0, 0);
|
|
}
|
|
}
|
|
} else {
|
|
let parallelQueue = pendingCandidates;
|
|
if (passwordCandidates.length > 1 && pendingCandidates.length > 1) {
|
|
logger.info(`Passwort-Discovery: Extrahiere erstes Archiv seriell (${passwordCandidates.length} Passwort-Kandidaten)...`);
|
|
options.onLog?.("INFO", `Passwort-Discovery: Extrahiere erstes Archiv seriell (${passwordCandidates.length} Passwort-Kandidaten)...`);
|
|
const first = pendingCandidates[0];
|
|
try {
|
|
await extractSingleArchive(first);
|
|
} catch (err) {
|
|
const errText = String(err);
|
|
if (/aborted:extract/i.test(errText)) throw err;
|
|
}
|
|
parallelQueue = pendingCandidates.slice(1);
|
|
if (parallelQueue.length > 0) {
|
|
logger.info(`Passwort-Discovery abgeschlossen, starte parallele Extraktion für ${parallelQueue.length} verbleibende Archive`);
|
|
}
|
|
}
|
|
|
|
if (parallelQueue.length > 0 && !options.signal?.aborted && !noExtractorEncountered) {
|
|
const queue = [...parallelQueue];
|
|
let nextIdx = 0;
|
|
let abortError: Error | null = null;
|
|
|
|
const worker = async (): Promise<void> => {
|
|
while (nextIdx < queue.length && !abortError && !noExtractorEncountered) {
|
|
if (options.signal?.aborted) break;
|
|
const idx = nextIdx;
|
|
nextIdx += 1;
|
|
try {
|
|
await extractSingleArchive(queue[idx]);
|
|
} catch (error) {
|
|
const errText = String(error);
|
|
if (errText.includes("noextractor:skipped")) {
|
|
break;
|
|
}
|
|
if (isExtractAbortError(errText)) {
|
|
abortError = error instanceof Error ? error : new Error(errText);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
const workerCount = Math.min(maxParallel, parallelQueue.length);
|
|
logger.info(`Parallele Extraktion: ${workerCount} gleichzeitige Worker für ${parallelQueue.length} Archive`);
|
|
const frozenPasswords = [...passwordCandidates];
|
|
await Promise.all(Array.from({ length: workerCount }, () => worker()));
|
|
passwordCandidates = frozenPasswords;
|
|
|
|
if (abortError) throw new Error("aborted:extract");
|
|
|
|
if (failed > 0 && extracted === 0) {
|
|
const failedArchives = parallelQueue.filter((ap) => !extractedArchives.has(ap) && !resumeCompleted.has(archiveNameKey(path.basename(ap))));
|
|
const failedCategories = failedArchives.map((archivePath) => failedArchiveCategories.get(archivePath) || "unknown");
|
|
if (failedArchives.length > 0 && shouldSerialRetryParallelFailures(extracted, failedCategories)) {
|
|
const categorySummary = [...new Set(failedCategories)].join(",");
|
|
logger.info(
|
|
`Serielle Wiederholung nach Parallel-Fehlstart: ${failedArchives.length} Archive werden einzeln wiederholt ` +
|
|
`(categories=${categorySummary || "unknown"})`
|
|
);
|
|
let retryRecovered = 0;
|
|
for (const archivePath of failedArchives) {
|
|
if (options.signal?.aborted || noExtractorEncountered) break;
|
|
try {
|
|
failed -= 1;
|
|
await extractSingleArchive(archivePath);
|
|
retryRecovered += 1;
|
|
} catch (retryError) {
|
|
const errText = String(retryError);
|
|
if (isExtractAbortError(errText)) throw retryError;
|
|
}
|
|
}
|
|
if (retryRecovered > 0) {
|
|
logger.info(`Serielle Wiederholung nach Parallel-Fehlstart: ${retryRecovered}/${failedArchives.length} Archive erfolgreich entpackt`);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (failed > 0 && extracted > 0) {
|
|
const failedArchives = parallelQueue.filter((ap) => !extractedArchives.has(ap) && !resumeCompleted.has(archiveNameKey(path.basename(ap))));
|
|
if (failedArchives.length > 0) {
|
|
logger.info(`Serielle Wiederholung: ${failedArchives.length} fehlgeschlagene Archive werden einzeln wiederholt (mögliche Parallelitäts-Kollision)`);
|
|
let retryRecovered = 0;
|
|
for (const archivePath of failedArchives) {
|
|
if (options.signal?.aborted || noExtractorEncountered) break;
|
|
try {
|
|
failed -= 1;
|
|
await extractSingleArchive(archivePath);
|
|
retryRecovered += 1;
|
|
} catch (retryError) {
|
|
const errText = String(retryError);
|
|
if (isExtractAbortError(errText)) throw retryError;
|
|
}
|
|
}
|
|
if (retryRecovered > 0) {
|
|
logger.info(`Serielle Wiederholung: ${retryRecovered}/${failedArchives.length} Archive erfolgreich entpackt`);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (noExtractorEncountered) {
|
|
const remaining = candidates.length - (extracted + failed);
|
|
if (remaining > 0) {
|
|
failed += remaining;
|
|
emitProgress(candidates.length, "", "extracting", 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (extracted > 0 && failed === 0 && !options.skipPostCleanup && !options.onlyArchives) {
|
|
try {
|
|
const nestedCandidates = (await findArchiveCandidates(options.targetDir))
|
|
.filter((p) => !NESTED_EXTRACT_BLACKLIST_RE.test(p));
|
|
if (nestedCandidates.length > 0) {
|
|
logger.info(`Nested-Extraction: ${nestedCandidates.length} Archive im Output gefunden`);
|
|
let nestedExtracted = 0;
|
|
let nestedFailed = 0;
|
|
try {
|
|
await checkDiskSpaceForExtraction(options.targetDir, nestedCandidates);
|
|
} catch (spaceError) {
|
|
logger.warn(`Nested-Extraction Disk-Space-Check fehlgeschlagen: ${String(spaceError)}`);
|
|
nestedCandidates.length = 0;
|
|
}
|
|
for (const nestedArchive of nestedCandidates) {
|
|
if (options.signal?.aborted) throw new Error("aborted:extract");
|
|
const nestedName = path.basename(nestedArchive);
|
|
const nestedKey = archiveNameKey(`nested:${nestedName}`);
|
|
if (resumeCompleted.has(nestedKey)) {
|
|
logger.info(`Nested-Extraction übersprungen (bereits entpackt): ${nestedName}`);
|
|
continue;
|
|
}
|
|
const nestedStartedAt = Date.now();
|
|
let nestedPercent = 0;
|
|
emitProgress(extracted + failed, `nested: ${nestedName}`, "extracting", nestedPercent, 0);
|
|
const nestedPulse = setInterval(() => {
|
|
emitProgress(extracted + failed, `nested: ${nestedName}`, "extracting", nestedPercent, Date.now() - nestedStartedAt);
|
|
}, 1100);
|
|
const hybrid = Boolean(options.hybridMode);
|
|
logger.info(`Nested-Entpacke: ${nestedName} -> ${options.targetDir}${hybrid ? " (hybrid)" : ""}`);
|
|
try {
|
|
const ext = path.extname(nestedArchive).toLowerCase();
|
|
if (ext === ".zip" && !(await shouldPreferExternalZip(nestedArchive))) {
|
|
try {
|
|
await extractZipArchive(nestedArchive, options.targetDir, options.conflictMode, options.signal);
|
|
nestedPercent = 100;
|
|
} catch (zipErr) {
|
|
if (!shouldFallbackToExternalZip(zipErr)) throw zipErr;
|
|
const usedPw = await runExternalExtract(nestedArchive, options.targetDir, options.conflictMode, passwordCandidates, (v) => { nestedPercent = Math.max(nestedPercent, v); }, options.signal, hybrid, undefined, false, undefined, options.onLog);
|
|
rememberLearnedPassword(usedPw);
|
|
}
|
|
} else {
|
|
const usedPw = await runExternalExtract(nestedArchive, options.targetDir, options.conflictMode, passwordCandidates, (v) => { nestedPercent = Math.max(nestedPercent, v); }, options.signal, hybrid, undefined, false, undefined, options.onLog);
|
|
rememberLearnedPassword(usedPw);
|
|
}
|
|
extracted += 1;
|
|
nestedExtracted += 1;
|
|
extractedArchives.add(nestedArchive);
|
|
resumeCompleted.add(nestedKey);
|
|
await writeExtractResumeState(options.packageDir, resumeCompleted, options.packageId);
|
|
logger.info(`Nested-Entpacken erfolgreich: ${nestedName}`);
|
|
if (options.cleanupMode !== "none") {
|
|
await cleanupArchives([nestedArchive], options.cleanupMode);
|
|
}
|
|
} catch (nestedErr) {
|
|
const errText = String(nestedErr);
|
|
if (isExtractAbortError(errText)) throw new Error("aborted:extract");
|
|
if (isNoExtractorError(errText)) {
|
|
logger.warn(`Nested-Extraction: Kein Extractor, überspringe restliche`);
|
|
break;
|
|
}
|
|
failed += 1;
|
|
nestedFailed += 1;
|
|
lastError = errText;
|
|
const nestedCategory = classifyExtractionError(errText);
|
|
logger.error(`Nested-Entpack-Fehler ${nestedName} [${nestedCategory}]: ${errText}`);
|
|
} finally {
|
|
clearInterval(nestedPulse);
|
|
}
|
|
}
|
|
logger.info(`Nested-Extraction abgeschlossen: ${nestedExtracted} entpackt, ${nestedFailed} fehlgeschlagen von ${nestedCandidates.length} Kandidaten`);
|
|
}
|
|
} catch (nestedError) {
|
|
const errText = String(nestedError);
|
|
if (isExtractAbortError(errText)) throw new Error("aborted:extract");
|
|
logger.warn(`Nested-Extraction Fehler: ${cleanErrorText(errText)}`);
|
|
}
|
|
}
|
|
|
|
if (extracted > 0) {
|
|
const hasOutputAfter = await hasAnyFilesRecursive(options.targetDir);
|
|
const hadResumeProgress = resumeCompletedAtStart > 0;
|
|
if (!hasOutputAfter && conflictMode !== "skip" && !hadResumeProgress) {
|
|
lastError = "Keine entpackten Dateien erkannt";
|
|
failed += extracted;
|
|
extracted = 0;
|
|
logger.error(`Entpacken ohne neue Ausgabe erkannt: ${options.targetDir}. Cleanup wird NICHT ausgeführt.`);
|
|
} else {
|
|
if (!options.skipPostCleanup) {
|
|
const cleanupSources = failed === 0 ? candidates : Array.from(extractedArchives.values());
|
|
const sourceAndTargetEqual = pathSetKey(path.resolve(options.packageDir)) === pathSetKey(path.resolve(options.targetDir));
|
|
const removedArchives = sourceAndTargetEqual
|
|
? 0
|
|
: await cleanupArchives(cleanupSources, options.cleanupMode);
|
|
if (sourceAndTargetEqual && options.cleanupMode !== "none") {
|
|
logger.warn(`Archive-Cleanup übersprungen (Quelle=Ziel): ${options.packageDir}`);
|
|
}
|
|
if (options.cleanupMode !== "none") {
|
|
logger.info(`Archive-Cleanup abgeschlossen: ${removedArchives} Datei(en) entfernt`);
|
|
}
|
|
if (options.removeLinks) {
|
|
const removedLinks = await removeDownloadLinkArtifacts(options.targetDir);
|
|
logger.info(`Link-Artefakt-Cleanup: ${removedLinks} Datei(en) entfernt`);
|
|
}
|
|
if (options.removeSamples) {
|
|
const removedSamples = await removeSampleArtifacts(options.targetDir);
|
|
logger.info(`Sample-Cleanup: ${removedSamples.files} Datei(en), ${removedSamples.dirs} Ordner entfernt`);
|
|
}
|
|
}
|
|
|
|
if (failed === 0 && resumeCompleted.size >= allCandidates.length && !options.skipPostCleanup) {
|
|
await clearExtractResumeState(options.packageDir, options.packageId);
|
|
}
|
|
|
|
if (!options.skipPostCleanup && options.cleanupMode === "delete" && !(await hasAnyFilesRecursive(options.packageDir))) {
|
|
const removedDirs = await removeEmptyDirectoryTree(options.packageDir);
|
|
if (removedDirs > 0) {
|
|
logger.info(`Leere Download-Ordner entfernt: ${removedDirs} (root=${options.packageDir})`);
|
|
}
|
|
}
|
|
}
|
|
} else if (!options.skipPostCleanup) {
|
|
try {
|
|
const targetExists = await fs.promises.access(options.targetDir).then(() => true, () => false);
|
|
if (targetExists && (await fs.promises.readdir(options.targetDir)).length === 0) {
|
|
await fs.promises.rm(options.targetDir, { recursive: true, force: true });
|
|
}
|
|
} catch {
|
|
}
|
|
}
|
|
|
|
if (failed > 0) {
|
|
if (resumeCompleted.size > 0) {
|
|
await writeExtractResumeState(options.packageDir, resumeCompleted, options.packageId);
|
|
} else {
|
|
await clearExtractResumeState(options.packageDir, options.packageId);
|
|
}
|
|
}
|
|
|
|
emitProgress(extracted, "", "done");
|
|
|
|
logger.info(`Entpacken beendet: extracted=${extracted}, failed=${failed}, targetDir=${options.targetDir}`);
|
|
|
|
return { extracted, failed, lastError };
|
|
}
|