wowdump 0.2.0 → 0.3.1

package/dist/cli.js

@@ -0,0 +1,497 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
+import { readFile, readdir } from "node:fs/promises";
+import { basename, extname, isAbsolute, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { Command } from "commander";
+import { WindowsBrokerManager } from "./windows-launcher.js";
+import { bootstrapToolchain, resolveToolchain, resolveWowdumpHome } from "./toolchain.js";
+import { runGhidraStaticAnalysis as runCanonicalGhidraStaticAnalysis, buildGhidraHeadlessCommand } from "./ghidra.js";
+async function runStaticAnalysis(options) {
+    // ghidra.ts owns the canonical evidence/profile schema. Keep the small
+    // toolchain resolver as the CLI-facing bootstrap layer, then translate the
+    // command options into the canonical runner's vocabulary.
+    const ghidraValue = options.ghidra;
+    const ghidraResolved = ghidraValue ? resolve(ghidraValue) : undefined;
+    const ghidraIsFile = ghidraResolved ? existsSync(ghidraResolved) && !existsSync(join(ghidraResolved, "support")) : false;
+    const canonicalOptions = {
+        exe: options.executable,
+        buildKey: options.buildKey,
+        output: options.evidenceFile ?? join(options.outputDirectory ?? resolveWowdumpHome(options.env ?? process.env), "profiles", `${options.buildKey.replace(/[^A-Za-z0-9_.-]+/g, "-")}.json`),
+        projectDir: options.projectDirectory,
+        projectName: options.projectName,
+        ghidraHome: ghidraResolved && !ghidraIsFile ? ghidraResolved : undefined,
+        analyzeHeadless: ghidraResolved && ghidraIsFile ? ghidraResolved : undefined,
+        javaPath: options.java,
+        scriptPath: options.scriptDirectory,
+        scriptName: options.exporterScript,
+        timeoutMs: (options.timeoutSeconds ?? 1800) * 1000,
+        env: options.env,
+        home: options.home,
+        commandRunner: options.runner
+            ? async (file, args, commandOptions) => {
+                const value = await options.runner({ file, args: [...args], cwd: commandOptions.cwd, env: commandOptions.env });
+                return { code: value.exitCode, stdout: value.stdout, stderr: value.stderr };
+            }
+            : undefined
+    };
+    if (options.dryRun) {
+        const resolved = resolveToolchain(options);
+        if (!resolved.ghidra || !resolved.java) {
+            throw new CliError("TOOLCHAIN_INCOMPLETE", `Ghidra toolchain is incomplete: missing ${resolved.missing.join(", ")}`, resolved);
+        }
+        const projectDir = options.projectDirectory ?? join(resolved.home, "cache", "ghidra", options.buildKey.replace(/[^A-Za-z0-9_.-]+/g, "-"));
+        const command = buildGhidraHeadlessCommand({ analyzeHeadless: resolved.ghidra.executable, javaPath: resolved.java.executable }, {
+            exe: options.executable,
+            buildKey: options.buildKey,
+            projectDir,
+            projectName: options.projectName,
+            scriptPath: options.scriptDirectory,
+            scriptName: options.exporterScript,
+            output: options.evidenceFile
+        });
+        return {
+            ok: true,
+            command: "analyze.static",
+            dryRun: true,
+            buildKey: options.buildKey,
+            executable: resolve(options.executable),
+            outputFile: options.evidenceFile ?? join(projectDir, `${options.buildKey.replace(/[^A-Za-z0-9_.-]+/g, "-")}.json`),
+            commandLine: { file: command.executable, args: command.args, cwd: command.cwd },
+            toolchain: resolved,
+            profile: { schema: "wowdump.profile.v1", buildKey: options.buildKey, confidence: "candidate" }
+        };
+    }
+    const result = await runCanonicalGhidraStaticAnalysis(canonicalOptions);
+    return {
+        ok: true,
+        command: "analyze.static",
+        dryRun: false,
+        buildKey: result.buildKey,
+        executable: result.executable.path,
+        executableSha256: result.executable.sha256,
+        outputFile: options.evidenceFile ?? join(options.outputDirectory ?? resolveWowdumpHome(options.env ?? process.env), "profiles", `${options.buildKey.replace(/[^A-Za-z0-9_.-]+/g, "-")}.json`),
+        commandLine: { file: result.analysis.command[0] ?? "", args: result.analysis.command.slice(1), cwd: options.projectDirectory ?? resolveWowdumpHome(options.env ?? process.env) },
+        toolchain: resolveToolchain(options),
+        profile: result.profile,
+        evidence: result
+    };
+}
+class CliError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.name = "CliError";
+        this.code = code;
+        this.details = details;
+    }
+}
+function positiveInteger(value, field) {
+    const result = Number(value);
+    if (!Number.isSafeInteger(result) || result <= 0)
+        throw new CliError("ARGUMENT_INVALID", `${field} must be a positive integer`);
+    return result;
+}
+function nonNegativeInteger(value, field) {
+    const result = Number(value);
+    if (!Number.isSafeInteger(result) || result < 0)
+        throw new CliError("ARGUMENT_INVALID", `${field} must be a non-negative integer`);
+    return result;
+}
+function jsonRecord(value, field) {
+    let decoded;
+    try {
+        decoded = JSON.parse(value);
+    }
+    catch {
+        throw new CliError("ARGUMENT_INVALID", `${field} must be valid JSON`);
+    }
+    if (!decoded || typeof decoded !== "object" || Array.isArray(decoded)) {
+        throw new CliError("ARGUMENT_INVALID", `${field} must be a JSON object`);
+    }
+    return decoded;
+}
+function writeJson(io, value) {
+    io.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+async function defaultSidecar(file, args, input) {
+    return new Promise(resolveResult => {
+        const child = spawn(file, args, { windowsHide: true, stdio: ["pipe", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", value => { stdout += value; });
+        child.stderr.on("data", value => { stderr += value; });
+        child.once("error", error => resolveResult({ exitCode: 1, stdout, stderr: `${stderr}${error.message}` }));
+        child.once("exit", code => resolveResult({ exitCode: code ?? 1, stdout, stderr }));
+        if (input !== undefined)
+            child.stdin.end(input);
+        else
+            child.stdin.end();
+    });
+}
+function brokerCommandLine(env, cwd) {
+    const configured = env.WOWDUMP_READER_COMMAND?.trim();
+    if (configured)
+        return { file: configured, args: [] };
+    const candidate = resolve(cwd, "dist", "reader-main.js");
+    return existsSync(candidate) ? { file: process.execPath, args: [candidate, "--request-stdio"] } : null;
+}
+async function defaultBroker(invocation, env, cwd, sidecar) {
+    const command = brokerCommandLine(env, cwd);
+    if (!command) {
+        throw new CliError("BROKER_NOT_CONFIGURED", "reader broker entry was not found", { expected: resolve(cwd, "dist", "reader-main.js"), environment: "WOWDUMP_READER_COMMAND" });
+    }
+    const result = await (sidecar ?? defaultSidecar)(command.file, command.args, `${JSON.stringify(invocation)}\n`);
+    if (result.exitCode !== 0)
+        throw new CliError("BROKER_FAILED", result.stderr.trim() || `reader broker exited with ${result.exitCode}`);
+    const line = result.stdout.split(/\r?\n/).find(value => value.trim());
+    if (!line)
+        throw new CliError("BROKER_PROTOCOL_ERROR", "reader broker returned no JSON response");
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        throw new CliError("BROKER_PROTOCOL_ERROR", "reader broker returned invalid JSON", { stdout: result.stdout });
+    }
+}
+const windowsBrokerManagers = new Map();
+function persistentWindowsBroker(home, cwd) {
+    const key = resolve(home).toLowerCase();
+    let manager = windowsBrokerManagers.get(key);
+    if (!manager) {
+        manager = new WindowsBrokerManager({ home, readerEntry: resolve(cwd, "dist", "reader-main.js") });
+        windowsBrokerManagers.set(key, manager);
+    }
+    return manager;
+}
+async function listProfileFiles(directory) {
+    try {
+        const entries = await readdir(directory, { withFileTypes: true });
+        return entries
+            .filter(entry => entry.isFile() && extname(entry.name).toLowerCase() === ".json")
+            .map(entry => join(directory, entry.name))
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+async function readProfileSummary(file) {
+    const profile = jsonRecord(await readFile(file, "utf8"), file);
+    return {
+        id: typeof profile.id === "string" ? profile.id : basename(file, extname(file)),
+        file,
+        buildKey: profile.buildKey ?? null,
+        confidence: profile.confidence ?? "unverified",
+        executableSha256: profile.executableSha256
+            ?? (profile.executable && typeof profile.executable === "object" && !Array.isArray(profile.executable)
+                ? profile.executable.sha256 ?? null
+                : null)
+    };
+}
+function profileFile(profileRoot, idOrFile) {
+    if (isAbsolute(idOrFile))
+        return resolve(idOrFile);
+    const safeId = idOrFile.replace(/\.json$/i, "");
+    if (!/^[A-Za-z0-9_.@-]+$/.test(safeId))
+        throw new CliError("ARGUMENT_INVALID", "profile ID contains unsupported characters");
+    return join(profileRoot, `${safeId}.json`);
+}
+function selected(source, keys) {
+    return Object.fromEntries(keys.filter(key => source[key] !== undefined).map(key => [key, source[key]]));
+}
+function requireRuntimeConfirmation(options) {
+    if (options.confirm === true)
+        return;
+    throw new CliError("CONFIRMATION_REQUIRED", "runtime export requires --confirm", {
+        pid: options.pid,
+        buildKey: options.build,
+        operation: "runtime-export",
+        kind: options.kind,
+        maxHooks: options.maxHooks,
+        durationMs: options.durationMs,
+        maxEvents: options.maxEvents,
+        cleanupDeadlineMs: options.cleanupDeadlineMs
+    });
+}
+function nested(record, ...path) {
+    let value = record;
+    for (const key of path) {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return undefined;
+        value = value[key];
+    }
+    return value;
+}
+function compareEvidence(staticProfile, runtimeExport) {
+    const definitions = [
+        { name: "buildKey", left: staticProfile.buildKey, right: runtimeExport.buildKey },
+        {
+            name: "executableSha256",
+            left: staticProfile.executableSha256 ?? nested(staticProfile, "executable", "sha256"),
+            right: runtimeExport.executableSha256 ?? nested(runtimeExport, "executable", "sha256")
+        },
+        { name: "moduleBase", left: staticProfile.moduleBase ?? nested(staticProfile, "module", "base"), right: runtimeExport.moduleBase ?? nested(runtimeExport, "module", "base") },
+        { name: "sectionBounds", left: staticProfile.sectionBounds ?? staticProfile.sections, right: runtimeExport.sectionBounds ?? runtimeExport.sections },
+        { name: "entryBytes", left: staticProfile.entryBytes, right: runtimeExport.entryBytes },
+        { name: "matchCount", left: staticProfile.matchCount, right: runtimeExport.matchCount }
+    ];
+    return definitions.map(item => ({
+        name: item.name,
+        static: item.left ?? null,
+        runtime: item.right ?? null,
+        status: item.left === undefined || item.right === undefined
+            ? "missing"
+            : JSON.stringify(item.left) === JSON.stringify(item.right) ? "match" : "mismatch"
+    }));
+}
+export function createWowdumpCli(dependencies = {}) {
+    const io = dependencies.io ?? { stdout: process.stdout, stderr: process.stderr };
+    const env = dependencies.env ?? process.env;
+    const cwd = resolve(dependencies.cwd ?? process.cwd());
+    const home = resolveWowdumpHome(env);
+    const broker = dependencies.broker ?? (process.platform === "win32" && !dependencies.sidecar
+        ? (invocation => persistentWindowsBroker(home, cwd).request(invocation))
+        : (invocation => defaultBroker(invocation, env, cwd, dependencies.sidecar)));
+    const staticAnalysis = dependencies.staticAnalysis ?? runStaticAnalysis;
+    const sidecar = dependencies.sidecar ?? defaultSidecar;
+    const program = new Command()
+        .name("wowdump")
+        .description("Build-aware WoW native memory analysis CLI")
+        .version("0.3.0")
+        .showHelpAfterError()
+        .configureOutput({ writeOut: value => io.stdout.write(value), writeErr: value => io.stderr.write(value) });
+    program.command("target")
+        .description("Show target, reader broker, profile, monitor, and Frida state")
+        .option("--pid <pid>", "target process ID")
+        .option("--build <buildKey>", "expected build key")
+        .action(async (options) => {
+        const payload = {
+            ...(options.pid ? { pid: positiveInteger(options.pid, "pid") } : {}),
+            ...(options.build ? { buildKey: options.build } : {})
+        };
+        const status = await broker({ command: "status", payload });
+        writeJson(io, { ok: true, command: "target", home, broker: status, toolchain: resolveToolchain({ home, env }) });
+    });
+    program.command("profiles")
+        .description("List profiles or describe one profile")
+        .argument("[id-or-file]", "profile ID or absolute JSON file")
+        .option("--directory <path>", "profile directory", join(home, "profiles"))
+        .action(async (idOrFile, options) => {
+        const directory = resolve(options.directory);
+        if (idOrFile) {
+            const file = profileFile(directory, idOrFile);
+            const profile = jsonRecord(await readFile(file, "utf8"), file);
+            writeJson(io, { ok: true, command: "profiles.describe", file, profile });
+            return;
+        }
+        const files = await listProfileFiles(directory);
+        writeJson(io, { ok: true, command: "profiles.list", directory, profiles: await Promise.all(files.map(readProfileSummary)) });
+    });
+    const memory = program.command("memory").description("Read or monitor profile-defined native memory");
+    memory.command("read")
+        .description("Perform one bounded read")
+        .requiredOption("--pid <pid>", "target process ID")
+        .option("--build <buildKey>", "expected build key")
+        .option("--profile <id>", "profile ID")
+        .option("--field <name...>", "field names")
+        .option("--address <hex>", "explicit address as hexadecimal text")
+        .option("--size <bytes>", "bounded byte count")
+        .option("--request <json>", "complete read request as JSON")
+        .action(async (options) => {
+        const payload = options.request ? jsonRecord(options.request, "request") : {
+            pid: positiveInteger(options.pid, "pid"),
+            ...(options.build ? { buildKey: options.build } : {}),
+            ...(options.profile ? { profileId: options.profile } : {}),
+            ...(options.field ? { fields: options.field } : {}),
+            ...(options.address ? { address: options.address } : {}),
+            ...(options.size ? { size: positiveInteger(options.size, "size") } : {})
+        };
+        writeJson(io, await broker({ command: "read", payload }));
+    });
+    const watch = memory.command("watch").description("Manage broker-owned memory monitors");
+    watch.command("start")
+        .description("Start a monitor")
+        .requiredOption("--pid <pid>", "target process ID")
+        .option("--build <buildKey>", "expected build key")
+        .option("--profile <id>", "profile ID")
+        .option("--field <name...>", "field names")
+        .option("--address <hex>", "explicit address as hexadecimal text")
+        .option("--size <bytes>", "bounded byte count")
+        .option("--interval <ms>", "sample interval", "250")
+        .option("--max-samples <count>", "sample limit", "1000")
+        .option("--all-samples", "emit unchanged samples")
+        .action(async (options) => writeJson(io, await broker({ command: "watch.start", payload: {
+            pid: positiveInteger(options.pid, "pid"),
+            ...(options.build ? { buildKey: options.build } : {}),
+            ...(options.profile ? { profileId: options.profile } : {}),
+            ...(options.field ? { fields: options.field } : {}),
+            ...(options.address ? { address: options.address } : {}),
+            ...(options.size ? { size: positiveInteger(options.size, "size") } : {}),
+            intervalMs: positiveInteger(options.interval, "interval"),
+            maxSamples: positiveInteger(options.maxSamples, "max-samples"),
+            changeOnly: options.allSamples !== true
+        } })));
+    watch.command("poll")
+        .description("Poll monitor events")
+        .requiredOption("--id <watchId>", "monitor ID")
+        .option("--after <sequence>", "sequence cursor", "0")
+        .action(async (options) => writeJson(io, await broker({ command: "watch.poll", payload: {
+            watchId: options.id,
+            afterSequence: nonNegativeInteger(options.after, "after")
+        } })));
+    watch.command("stop")
+        .description("Stop a monitor and release its resources")
+        .requiredOption("--id <watchId>", "monitor ID")
+        .action(async (options) => writeJson(io, await broker({ command: "watch.stop", payload: { watchId: options.id } })));
+    const analyze = program.command("analyze").description("Run separate static, runtime-export, and verification stages");
+    analyze.command("static")
+        .description("Analyze a disk executable with Ghidra Headless")
+        .requiredOption("--exe <path>", "path to Wow.exe")
+        .requiredOption("--build <buildKey>", "build key")
+        .option("--build-key <buildKey>", "alias for --build")
+        .option("--java <path>", "Java executable or JDK root")
+        .option("--ghidra <path>", "analyzeHeadless executable or Ghidra root")
+        .option("--output <directory>", "profile output directory")
+        .option("--project-directory <directory>", "Ghidra project directory")
+        .option("--project-name <name>", "Ghidra project name")
+        .option("--script-directory <directory>", "Ghidra script directory")
+        .option("--exporter-script <name>", "Ghidra post-script name")
+        .option("--evidence <file>", "Ghidra exporter JSON output")
+        .option("--timeout <seconds>", "analysis timeout", "1800")
+        .option("--dry-run", "print the exact command without starting Ghidra")
+        .action(async (options) => writeJson(io, await staticAnalysis({
+        executable: options.exe,
+        buildKey: options.build ?? options.buildKey,
+        home,
+        env,
+        java: options.java,
+        ghidra: options.ghidra,
+        outputDirectory: options.output,
+        projectDirectory: options.projectDirectory,
+        projectName: options.projectName,
+        scriptDirectory: options.scriptDirectory,
+        exporterScript: options.exporterScript,
+        evidenceFile: options.evidence,
+        timeoutSeconds: positiveInteger(options.timeout, "timeout"),
+        dryRun: options.dryRun === true
+    })));
+    analyze.command("runtime-export")
+        .description("Export runtime evidence through the isolated Frida sidecar")
+        .requiredOption("--pid <pid>", "target process ID")
+        .requiredOption("--build <buildKey>", "build key")
+        .option("--build-key <buildKey>", "alias for --build")
+        .option("--kind <kind>", "text or providers", "providers")
+        .option("--worker <path>", "Frida worker entry")
+        .option("--static-profile <path>", "static profile containing candidate RVAs")
+        .option("--max-hooks <count>", "maximum hooks", "1")
+        .option("--duration-ms <ms>", "maximum duration", "5000")
+        .option("--max-events <count>", "maximum events", "100")
+        .option("--cleanup-deadline-ms <ms>", "cleanup deadline", "2000")
+        .option("--confirm", "confirm the exact bounded Frida operation")
+        .action(async (options) => {
+        const normalized = {
+            pid: positiveInteger(options.pid, "pid"),
+            build: options.build ?? options.buildKey,
+            kind: options.kind,
+            maxHooks: positiveInteger(options.maxHooks, "max-hooks"),
+            durationMs: positiveInteger(options.durationMs, "duration-ms"),
+            maxEvents: positiveInteger(options.maxEvents, "max-events"),
+            cleanupDeadlineMs: positiveInteger(options.cleanupDeadlineMs, "cleanup-deadline-ms"),
+            confirm: options.confirm === true
+        };
+        if (!["text", "providers"].includes(normalized.kind))
+            throw new CliError("ARGUMENT_INVALID", "kind must be text or providers");
+        requireRuntimeConfirmation(normalized);
+        const worker = resolve(options.worker ?? env.WOWDUMP_FRIDA_WORKER ?? join(cwd, "dist", "frida-worker.js"));
+        if (!existsSync(worker))
+            throw new CliError("FRIDA_WORKER_NOT_FOUND", `Frida worker was not found: ${worker}`);
+        const request = {
+            command: "runtime-export",
+            ...selected(normalized, ["pid", "build", "kind", "maxHooks", "durationMs", "maxEvents", "cleanupDeadlineMs"]),
+            ...(options.staticProfile ? { staticProfile: resolve(options.staticProfile) } : {})
+        };
+        const result = await sidecar(process.execPath, [worker], `${JSON.stringify(request)}\n`);
+        if (result.exitCode !== 0)
+            throw new CliError("FRIDA_WORKER_FAILED", result.stderr.trim() || `Frida worker exited with ${result.exitCode}`);
+        const line = result.stdout.split(/\r?\n/).find(value => value.trim());
+        writeJson(io, line ? JSON.parse(line) : { ok: true, command: "analyze.runtime-export", stdout: result.stdout });
+    });
+    analyze.command("verify")
+        .description("Compare static and runtime evidence without implicit promotion")
+        .requiredOption("--static-profile <path>", "static profile JSON")
+        .requiredOption("--runtime-export <path>", "runtime export JSON")
+        .option("--output <path>", "optional verification report path")
+        .action(async (options) => {
+        const staticFile = resolve(options.staticProfile);
+        const runtimeFile = resolve(options.runtimeExport);
+        const staticProfile = jsonRecord(await readFile(staticFile, "utf8"), staticFile);
+        const runtimeExport = jsonRecord(await readFile(runtimeFile, "utf8"), runtimeFile);
+        const checks = compareEvidence(staticProfile, runtimeExport);
+        const report = {
+            ok: checks.every(check => check.status !== "mismatch"),
+            command: "analyze.verify",
+            staticProfile: staticFile,
+            runtimeExport: runtimeFile,
+            checks,
+            confidence: staticProfile.confidence ?? "unverified",
+            promoted: false
+        };
+        if (options.output) {
+            const { writeFile } = await import("node:fs/promises");
+            await writeFile(resolve(options.output), `${JSON.stringify(report, null, 2)}\n`, "utf8");
+        }
+        writeJson(io, report);
+    });
+    program.command("init")
+        .description("Initialize WOWDUMP_HOME without overwriting existing files")
+        .option("--skip-toolchain-download", "only detect existing Java/Ghidra installations")
+        .action(async (options) => {
+        const installMissing = options.skipToolchainDownload !== true && env.WOWDUMP_SKIP_TOOLCHAIN_DOWNLOAD !== "1";
+        const result = await bootstrapToolchain({ home, env, installMissing });
+        writeJson(io, {
+            ok: result.toolchain.ready,
+            command: "init",
+            ...result,
+            toolchain: result.toolchain
+        });
+    });
+    return program;
+}
+export async function runWowdumpCli(argv = process.argv, dependencies = {}) {
+    const io = dependencies.io ?? { stdout: process.stdout, stderr: process.stderr };
+    try {
+        await createWowdumpCli(dependencies).parseAsync([...argv]);
+        return 0;
+    }
+    catch (error) {
+        const failure = error;
+        io.stderr.write(`${JSON.stringify({
+            ok: false,
+            error: {
+                code: typeof failure.code === "string" ? failure.code : "CLI_FAILED",
+                message: error instanceof Error ? error.message : String(error),
+                ...(failure.details !== undefined ? { details: failure.details } : {})
+            }
+        })}\n`);
+        return 1;
+    }
+}
+let invokedFile = "";
+if (process.argv[1]) {
+    const invokedPath = resolve(process.argv[1]);
+    try {
+        invokedFile = pathToFileURL(realpathSync(invokedPath)).href;
+    }
+    catch {
+        invokedFile = pathToFileURL(invokedPath).href;
+    }
+}
+if (invokedFile === import.meta.url)
+    process.exitCode = await runWowdumpCli();

package/dist/discovery.js

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { basename, join, resolve } from "node:path";
+import { basename, join } from "node:path";
 function parseBuildInfo(file) {
     if (!existsSync(file))
         return [];
@@ -46,14 +46,3 @@ export function discoverInstalls(gameRoot) {
         return [{ flavor, root, executable, build }];
     }).sort((a, b) => a.flavor.localeCompare(b.flavor));
 }
-export function discoverInstallsAcrossRoots(gameRoots, discover = discoverInstalls) {
-    const installs = new Map();
-    for (const gameRoot of gameRoots) {
-        for (const install of discover(gameRoot)) {
-            const key = resolve(install.executable).toLowerCase();
-            if (!installs.has(key))
-                installs.set(key, install);
-        }
-    }
-    return [...installs.values()].sort((a, b) => a.flavor.localeCompare(b.flavor) || a.executable.localeCompare(b.executable));
-}

package/dist/dry-run.js

@@ -29,8 +29,6 @@ export function createDryRunReport(installs, processes, registry) {
         processes: processes
             .map(process => ({
             pid: process.pid,
-            executable: process.executable,
-            ...(process.startTime ? { startTime: process.startTime } : {}),
             ...installStatus(process.install, registry)
         }))
             .sort((a, b) => a.pid - b.pid)