wowdump 0.3.1 → 0.3.2

package/dist/main.js

@@ -1,66 +0,0 @@
-import { resolve } from "node:path";
-import { buildAdapterRegistry } from "./adapters.js";
-import { discoverInstalls } from "./discovery.js";
-import { createDryRunReport } from "./dry-run.js";
-import { listWowProcesses } from "./processes.js";
-const gameRoot = process.env.WOW_ROOT ?? "D:/Game/World of Warcraft";
-const agentFile = resolve(process.env.WOW_AGENT ?? "dist/agent.js");
-const output = resolve(process.env.WOW_ERRORS ?? "data/errors.jsonl");
-const pollMs = Number(process.env.WOW_POLL_MS ?? 1500);
-const installs = discoverInstalls(gameRoot);
-if (process.argv.includes("--discover")) {
-    console.log(JSON.stringify(installs, null, 2));
-}
-else if (process.argv.includes("--dry-run")) {
-    try {
-        const processes = await listWowProcesses(installs);
-        console.log(JSON.stringify(createDryRunReport(installs, processes, buildAdapterRegistry), null, 2));
-    }
-    catch (error) {
-        console.error("process scan:", error);
-        process.exitCode = 1;
-    }
-}
-else {
-    await runCollector();
-}
-async function runCollector() {
-    const [{ ProcessSession }, { JsonlStore }] = await Promise.all([
-        import("./session.js"),
-        import("./storage.js")
-    ]);
-    console.log(`Discovered ${installs.length} WoW installs under ${gameRoot}`);
-    const store = new JsonlStore(output);
-    const sessions = new Map();
-    async function poll() {
-        const processes = await listWowProcesses(installs).catch(error => {
-            console.error("process scan:", error);
-            return [];
-        });
-        const live = new Set(processes.map(process => process.pid));
-        for (const [pid, session] of sessions) {
-            if (!live.has(pid)) {
-                await session.detach();
-                sessions.delete(pid);
-            }
-        }
-        for (const process of processes) {
-            if (sessions.has(process.pid))
-                continue;
-            const session = new ProcessSession(process, agentFile, store);
-            await session.attach()
-                .then(() => sessions.set(process.pid, session))
-                .catch(error => console.error(`attach ${process.pid}:`, error));
-        }
-    }
-    await poll();
-    const timer = setInterval(() => void poll(), pollMs);
-    const shutdown = async () => {
-        clearInterval(timer);
-        for (const session of sessions.values())
-            await session.detach();
-        process.exit(0);
-    };
-    process.once("SIGINT", shutdown);
-    process.once("SIGTERM", shutdown);
-}

package/dist/observability.js

@@ -1,41 +0,0 @@
-export const OBSERVATION_TIERS = [
-    "error_text",
-    "source_location",
-    "stack_trace",
-    "vm_metadata"
-];
-export const OBSERVATION_TIER_DEFINITIONS = Object.freeze([
-    Object.freeze({
-        tier: "error_text",
-        capability: "errorMessage",
-        description: "Read the existing error text at a verified error boundary"
-    }),
-    Object.freeze({
-        tier: "source_location",
-        capability: "sourceLocation",
-        description: "Read source and line metadata when its layout is proven"
-    }),
-    Object.freeze({
-        tier: "stack_trace",
-        capability: "stackTrace",
-        description: "Read an existing stack representation with bounded traversal"
-    }),
-    Object.freeze({
-        tier: "vm_metadata",
-        capability: "vmMetadata",
-        description: "Read build-specific VM metadata only after an exact proof"
-    })
-]);
-export function getObservationTiers(adapter) {
-    if (!adapter)
-        return Object.freeze([]);
-    return Object.freeze(OBSERVATION_TIER_DEFINITIONS
-        .filter(definition => adapter.capabilities[definition.capability])
-        .map(definition => definition.tier));
-}
-export function createObservationPolicy(adapter) {
-    return Object.freeze({
-        semanticReadOnly: true,
-        tiers: getObservationTiers(adapter)
-    });
-}

package/dist/processes.js

@@ -1,44 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { basename, resolve } from "node:path";
-const execFileAsync = promisify(execFile);
-export function parseWowProcessRows(stdout, installs) {
-    if (!stdout.trim() || stdout.trim() === "null")
-        return [];
-    const decoded = JSON.parse(stdout);
-    const rows = (Array.isArray(decoded) ? decoded : [decoded]).filter((row) => typeof row === "object" && row !== null && !Array.isArray(row));
-    return rows.flatMap(row => {
-        const pid = Number(row.ProcessId);
-        if (!Number.isSafeInteger(pid) || pid <= 0)
-            return [];
-        const observedExecutable = String(row.ExecutablePath ?? "");
-        let executable = observedExecutable;
-        let install;
-        if (observedExecutable) {
-            if (basename(observedExecutable).toLowerCase() !== "wow.exe")
-                return [];
-            install = installs.find(candidate => resolve(candidate.executable).toLowerCase() === resolve(observedExecutable).toLowerCase());
-        }
-        else if (row.Name === "Wow.exe" && installs.length === 1) {
-            install = installs[0];
-            executable = install.executable;
-        }
-        if (!install)
-            return [];
-        return [{
-                pid,
-                executable,
-                install,
-                commandLine: String(row.CommandLine ?? "")
-            }];
-    });
-}
-export async function listWowProcesses(installs) {
-    const { stdout } = await execFileAsync("powershell.exe", [
-        "-NoProfile",
-        "-NonInteractive",
-        "-Command",
-        "Get-CimInstance Win32_Process -Filter \"Name = 'Wow.exe'\" | Select-Object Name,ProcessId,ExecutablePath,CommandLine | ConvertTo-Json -Compress"
-    ], { windowsHide: true });
-    return parseWowProcessRows(stdout, installs);
-}

package/dist/session.js

@@ -1,42 +0,0 @@
-import { readFile } from "node:fs/promises";
-import * as frida from "frida";
-import { ErrorEventSchema } from "./types.js";
-export class ProcessSession {
-    process;
-    agentFile;
-    store;
-    session;
-    script;
-    constructor(process, agentFile, store) {
-        this.process = process;
-        this.agentFile = agentFile;
-        this.store = store;
-    }
-    async attach() {
-        if (this.session)
-            return;
-        this.session = await frida.attach(this.process.pid);
-        const source = await readFile(this.agentFile, "utf8");
-        this.script = await this.session.createScript(source);
-        this.script.message.connect(async (message) => {
-            if (message.type !== "send")
-                return;
-            const payload = message.payload;
-            const parsed = ErrorEventSchema.safeParse({
-                ...payload,
-                pid: this.process.pid,
-                buildKey: this.process.install.build.buildKey,
-                flavor: this.process.install.flavor
-            });
-            if (parsed.success)
-                await this.store.append(parsed.data);
-        });
-        await this.script.load();
-    }
-    async detach() {
-        await this.script?.unload().catch(() => undefined);
-        await this.session?.detach().catch(() => undefined);
-        this.script = undefined;
-        this.session = undefined;
-    }
-}

package/dist/storage.js

@@ -1,12 +0,0 @@
-import { appendFile, mkdir } from "node:fs/promises";
-import { dirname } from "node:path";
-export class JsonlStore {
-    file;
-    constructor(file) {
-        this.file = file;
-    }
-    async append(event) {
-        await mkdir(dirname(this.file), { recursive: true });
-        await appendFile(this.file, JSON.stringify(event) + "\n", "utf8");
-    }
-}

package/dist/windows-reader.js

@@ -1,102 +0,0 @@
-import koffi from "koffi";
-const PROCESS_QUERY_INFORMATION = 0x0400;
-const PROCESS_VM_READ = 0x0010;
-const HANDLE = koffi.pointer("WOWDUMP_HANDLE", koffi.opaque());
-const SIZE_T = process.arch === "x64" ? "uint64_t" : "uint32_t";
-const kernel32 = koffi.load("kernel32.dll");
-const shell32 = koffi.load("shell32.dll");
-const OpenProcess = kernel32.func("OpenProcess", HANDLE, ["uint32_t", "bool", "uint32_t"]);
-const ReadProcessMemory = kernel32.func("ReadProcessMemory", "bool", [HANDLE, "uint64_t", koffi.pointer("uint8_t"), SIZE_T, koffi.out(koffi.pointer(SIZE_T))]);
-const VirtualQueryEx = kernel32.func("VirtualQueryEx", SIZE_T, [HANDLE, "uint64_t", koffi.pointer("uint8_t"), SIZE_T]);
-const CloseHandle = kernel32.func("CloseHandle", "bool", [HANDLE]);
-const GetLastError = kernel32.func("GetLastError", "uint32_t", []);
-const IsUserAnAdmin = shell32.func("IsUserAnAdmin", "bool", []);
-function addressOf(handle) {
-    return `0x${koffi.address(handle).toString(16)}`;
-}
-function win32Error(operation) {
-    const win32 = Number(GetLastError());
-    const error = new Error(`${operation} failed with Win32 error ${win32}`);
-    error.code = "WIN32_ERROR";
-    error.win32 = win32;
-    return error;
-}
-class WindowsHandle {
-    raw;
-    pid;
-    id;
-    constructor(raw, pid) {
-        this.raw = raw;
-        this.pid = pid;
-        this.id = addressOf(raw);
-    }
-    close() {
-        if (this.raw !== null) {
-            CloseHandle(this.raw);
-            this.raw = null;
-        }
-    }
-}
-export class WindowsNativeReader {
-    async openProcess(pid, rights) {
-        const requested = rights.reduce((mask, right) => {
-            if (right === "PROCESS_QUERY_INFORMATION")
-                return mask | PROCESS_QUERY_INFORMATION;
-            if (right === "PROCESS_VM_READ")
-                return mask | PROCESS_VM_READ;
-            return mask;
-        }, 0);
-        const handle = OpenProcess(requested || PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, pid);
-        if (!handle)
-            throw win32Error(`OpenProcess(${pid})`);
-        return new WindowsHandle(handle, pid);
-    }
-    async readProcessMemory(handle, address, size) {
-        const native = handle;
-        const bytes = Buffer.allocUnsafe(size);
-        const read = [0n];
-        const ok = ReadProcessMemory(native.raw, address, bytes, size, read);
-        const bytesRead = Number(read[0]);
-        if (!ok && bytesRead === 0)
-            throw win32Error(`ReadProcessMemory(${native.id}, ${`0x${address.toString(16)}`})`);
-        return { bytes: bytes.subarray(0, bytesRead), bytesRead };
-    }
-    async virtualQueryEx(handle, address) {
-        const native = handle;
-        const buffer = Buffer.alloc(48);
-        const result = Number(VirtualQueryEx(native.raw, address, buffer, buffer.length));
-        if (result === 0)
-            throw win32Error(`VirtualQueryEx(${native.id})`);
-        return {
-            baseAddress: `0x${buffer.readBigUInt64LE(0).toString(16)}`,
-            allocationBase: `0x${buffer.readBigUInt64LE(8).toString(16)}`,
-            allocationProtect: buffer.readUInt32LE(16),
-            regionSize: buffer.readBigUInt64LE(24).toString(),
-            state: buffer.readUInt32LE(32),
-            protect: buffer.readUInt32LE(36),
-            type: buffer.readUInt32LE(40),
-            bytesReturned: result
-        };
-    }
-    async isProcessAlive(pid) {
-        try {
-            const handle = await this.openProcess(pid, ["PROCESS_QUERY_INFORMATION"]);
-            handle.close();
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    elevationStatus() {
-        return {
-            elevated: Boolean(IsUserAnAdmin()),
-            processArchitecture: process.arch,
-            backend: "koffi/kernel32",
-            requestedRights: ["PROCESS_QUERY_INFORMATION", "PROCESS_VM_READ"]
-        };
-    }
-}
-export function createWindowsNativeReader() {
-    return new WindowsNativeReader();
-}