wowdump 0.3.1 → 0.3.2

package/dist/core/profile-engine.js

@@ -0,0 +1,238 @@
+export class ProfileEngineError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.name = "ProfileEngineError";
+        this.code = code;
+        this.details = details;
+    }
+}
+const SCALAR_SIZES = {
+    u8: 1, i8: 1, u16: 2, i16: 2, u32: 4, i32: 4,
+    u64: 8, i64: 8, f32: 4, f64: 8, pointer: 8,
+    bytes: undefined, utf8: undefined, utf16: undefined
+};
+function record(value, name) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new ProfileEngineError("PROFILE_INVALID", `${name} must be an object`);
+    }
+    return value;
+}
+function hex(value, name) {
+    if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0)
+        return BigInt(value);
+    if (typeof value !== "string" || !/^0x[0-9a-f]+$/i.test(value.trim())) {
+        throw new ProfileEngineError("PROFILE_INVALID", `${name} must be a 0x-prefixed hexadecimal value`);
+    }
+    return BigInt(value);
+}
+function hexText(value) {
+    return `0x${value.toString(16)}`;
+}
+function integer(value, name, maximum = 16 * 1024 * 1024) {
+    const result = typeof value === "number" ? value : Number(value);
+    if (!Number.isSafeInteger(result) || result < 0 || result > maximum) {
+        throw new ProfileEngineError("PROFILE_INVALID", `${name} must be an integer between 0 and ${maximum}`);
+    }
+    return result;
+}
+function scalarType(value, name) {
+    if (typeof value !== "string" || !(value in SCALAR_SIZES)) {
+        throw new ProfileEngineError("PROFILE_INVALID", `${name} has an unsupported scalar type`);
+    }
+    return value;
+}
+function layoutOf(field) {
+    const layout = field.layout;
+    if (layout === undefined)
+        return { kind: "scalar", type: field.type ?? "pointer" };
+    return record(layout, "field.layout");
+}
+function layoutSize(layout) {
+    const kind = String(layout.kind ?? "scalar");
+    if (kind === "scalar") {
+        const type = scalarType(layout.type, "layout.type");
+        const size = SCALAR_SIZES[type];
+        if (size === undefined)
+            return integer(layout.size, "layout.size", 16 * 1024 * 1024);
+        return size;
+    }
+    if (kind === "struct") {
+        let size = layout.size === undefined ? 0 : integer(layout.size, "struct.size");
+        const fields = record(layout.fields ?? {}, "struct.fields");
+        for (const value of Object.values(fields)) {
+            const field = record(value, "struct field");
+            const offset = integer(hex(field.offset, "field.offset"), "field.offset");
+            size = Math.max(size, offset + layoutSize(field.layout ? record(field.layout, "field.layout") : field));
+        }
+        return size;
+    }
+    if (kind === "array") {
+        const item = record(layout.item, "array.item");
+        const stride = integer(layout.stride ?? layoutSize(item), "array.stride");
+        const count = layout.count;
+        if (typeof count === "number" || typeof count === "string")
+            return stride * integer(count, "array.count", 100000);
+        return stride * integer(layout.maxItems, "array.maxItems", 100000);
+    }
+    if (kind === "linked_list") {
+        const item = record(layout.item, "linked_list.item");
+        return Math.max(layoutSize(item), integer(hex(layout.nextOffset ?? "0x8", "nextOffset"), "nextOffset") + 8);
+    }
+    throw new ProfileEngineError("PROFILE_INVALID", `unsupported layout kind ${kind}`);
+}
+function decodeScalar(type, bytes) {
+    switch (type) {
+        case "u8": return bytes.readUInt8(0);
+        case "i8": return bytes.readInt8(0);
+        case "u16": return bytes.readUInt16LE(0);
+        case "i16": return bytes.readInt16LE(0);
+        case "u32": return bytes.readUInt32LE(0);
+        case "i32": return bytes.readInt32LE(0);
+        case "u64": return hexText(bytes.readBigUInt64LE(0));
+        case "i64": return bytes.readBigInt64LE(0).toString();
+        case "f32": return bytes.readFloatLE(0);
+        case "f64": return bytes.readDoubleLE(0);
+        case "pointer": return hexText(bytes.readBigUInt64LE(0));
+        case "bytes": return bytes.toString("hex");
+        case "utf8": return bytes.toString("utf8").replace(/\0.*$/s, "");
+        case "utf16": return bytes.toString("utf16le").replace(/\0.*$/s, "");
+    }
+}
+function decodeInline(layout, bytes, base = 0) {
+    const kind = String(layout.kind ?? "scalar");
+    if (kind === "scalar") {
+        const type = scalarType(layout.type, "layout.type");
+        const size = SCALAR_SIZES[type] ?? integer(layout.size, "layout.size");
+        return decodeScalar(type, bytes.subarray(base, base + size));
+    }
+    if (kind === "struct") {
+        const result = {};
+        const fields = record(layout.fields ?? {}, "struct.fields");
+        for (const [name, value] of Object.entries(fields)) {
+            const field = record(value, `struct field ${name}`);
+            const offset = integer(hex(field.offset, `${name}.offset`), `${name}.offset`);
+            result[name] = decodeInline(field.layout ? record(field.layout, `${name}.layout`) : field, bytes, base + offset);
+        }
+        return result;
+    }
+    if (kind === "array") {
+        const item = record(layout.item, "array.item");
+        const stride = integer(layout.stride ?? layoutSize(item), "array.stride");
+        const count = integer(layout.count ?? layout.maxItems, "array.count", 100000);
+        return Array.from({ length: count }, (_, index) => decodeInline(item, bytes, base + index * stride));
+    }
+    throw new ProfileEngineError("PROFILE_INVALID", `inline layout ${kind} is not supported`);
+}
+function profileId(profile) {
+    return typeof profile.id === "string" && profile.id ? profile.id : String(profile.buildKey ?? "profile");
+}
+function rootSpec(value, name) {
+    const root = record(value, `${name}.root`);
+    if (root.rva === undefined && root.address === undefined)
+        throw new ProfileEngineError("PROFILE_INVALID", `${name}.root requires rva or address`);
+    return root;
+}
+export class ProfileEngine {
+    async read(request, adapter) {
+        const profile = record(request.profile, "profile");
+        const buildKey = String(profile.buildKey ?? "");
+        if (!buildKey)
+            throw new ProfileEngineError("PROFILE_INVALID", "profile.buildKey is required");
+        if (request.buildKey && request.buildKey !== buildKey) {
+            throw new ProfileEngineError("BUILD_MISMATCH", `profile build ${buildKey} does not match ${request.buildKey}`);
+        }
+        const status = String(profile.readerStatus ?? profile.status ?? (profile.confidence === "reader_ready" ? "reader_ready" : ""));
+        if (status !== "reader_ready")
+            throw new ProfileEngineError("PROFILE_NOT_READY", "profile is not reader_ready", { status });
+        const modules = await adapter.modules(request.pid);
+        const moduleSpec = profile.module && typeof profile.module === "object" ? record(profile.module, "profile.module") : {};
+        const moduleName = String(moduleSpec.name ?? profile.moduleName ?? "Wow.exe");
+        const module = modules.find(item => item.name.toLowerCase() === moduleName.toLowerCase());
+        if (!module)
+            throw new ProfileEngineError("MODULE_NOT_FOUND", `${moduleName} was not found`, { modules: modules.map(item => item.name) });
+        const definitions = record(profile.fields ?? profile.readers, "profile.fields");
+        const names = request.fields?.length ? [...request.fields] : Object.keys(definitions);
+        const fields = {};
+        const reads = [];
+        for (const name of names) {
+            const definition = record(definitions[name], `field ${name}`);
+            fields[name] = await this.readField(request.pid, hex(module.base, "module.base"), name, definition, adapter, reads);
+        }
+        return { ok: true, command: "profile.read", pid: request.pid, buildKey, profileId: profileId(profile), module, fields, reads };
+    }
+    async readField(pid, moduleBase, fieldName, definition, adapter, reads) {
+        let address = definition.root === undefined ? moduleBase : await this.resolveRoot(pid, moduleBase, rootSpec(definition.root, fieldName), adapter, fieldName, reads);
+        const chainValue = definition.pointerChain ?? definition.chain;
+        const chain = Array.isArray(chainValue) ? chainValue : [];
+        for (const value of chain) {
+            const step = record(value, `${fieldName}.pointerChain`);
+            address += hex(step.offset ?? "0x0", `${fieldName}.pointerChain.offset`);
+            if (step.dereference === false)
+                continue;
+            const pointer = await this.readBytes(pid, address, 8, fieldName, adapter, reads);
+            address = BigInt(`0x${pointer.toString("hex").match(/../g).reverse().join("")}`);
+            const mask = step.mask === undefined ? 0n : hex(step.mask, `${fieldName}.pointerChain.mask`);
+            if (mask)
+                address &= mask;
+            if (address === 0n)
+                throw new ProfileEngineError("NULL_POINTER", `${fieldName} resolved to a null pointer`);
+        }
+        return this.readLayout(pid, address, layoutOf(definition), fieldName, adapter, reads);
+    }
+    async resolveRoot(pid, moduleBase, root, adapter, field, reads) {
+        let address = root.address === undefined ? moduleBase + hex(root.rva, `${field}.root.rva`) : hex(root.address, `${field}.root.address`);
+        if (root.dereference === true) {
+            const bytes = await this.readBytes(pid, address, 8, field, adapter, reads);
+            address = BigInt(`0x${bytes.toString("hex").match(/../g).reverse().join("")}`);
+        }
+        return address;
+    }
+    async readLayout(pid, address, layout, field, adapter, reads) {
+        const kind = String(layout.kind ?? "scalar");
+        if (kind === "linked_list") {
+            const item = record(layout.item, `${field}.item`);
+            const nextOffset = integer(hex(layout.nextOffset ?? "0x8", `${field}.nextOffset`), `${field}.nextOffset`);
+            const itemSize = Math.max(layoutSize(item), nextOffset + 8);
+            const maxItems = integer(layout.maxItems ?? 64, `${field}.maxItems`, 100000);
+            const values = [];
+            const seen = new Set();
+            while (address !== 0n && values.length < maxItems) {
+                const key = hexText(address);
+                if (seen.has(key))
+                    throw new ProfileEngineError("POINTER_CYCLE", `${field} linked list contains a cycle`, { address: key });
+                seen.add(key);
+                if (layout.stopOnTagged !== false && (address & 1n) !== 0n)
+                    break;
+                const bytes = await this.readBytes(pid, address, itemSize, field, adapter, reads);
+                values.push(decodeInline(item, bytes));
+                const nextBytes = bytes.subarray(nextOffset, nextOffset + 8);
+                address = nextBytes.length < 8 ? 0n : BigInt(`0x${nextBytes.toString("hex").match(/../g).reverse().join("")}`);
+            }
+            return values;
+        }
+        const size = layout.kind === "scalar" && layout.type && SCALAR_SIZES[scalarType(layout.type, `${field}.type`)] === undefined
+            ? integer(layout.size, `${field}.size`)
+            : layoutSize(layout);
+        const bytes = await this.readBytes(pid, address, size, field, adapter, reads);
+        if (kind === "array" && layout.count === undefined && layout.maxItems !== undefined) {
+            const item = record(layout.item, `${field}.item`);
+            const stride = integer(layout.stride ?? layoutSize(item), `${field}.stride`);
+            const count = integer(layout.maxItems, `${field}.maxItems`, 100000);
+            return Array.from({ length: count }, (_, index) => decodeInline(item, bytes, index * stride));
+        }
+        return decodeInline(layout, bytes);
+    }
+    async readBytes(pid, address, size, field, adapter, reads) {
+        const result = await adapter.read(pid, hexText(address), size);
+        if (!result.ok || typeof result.dataHex !== "string")
+            throw new ProfileEngineError("READ_FAILED", `${field} read failed`, { address: hexText(address), size, error: result.error ?? null });
+        const bytesRead = Number(result.bytesRead ?? result.dataHex.length / 2);
+        const bytes = Buffer.from(result.dataHex, "hex");
+        reads.push({ field, address: hexText(address), size, bytesRead, dataHex: result.dataHex, complete: result.complete === true && bytesRead === size });
+        if (bytesRead !== size || bytes.length < size)
+            throw new ProfileEngineError("PARTIAL_READ", `${field} read was incomplete`, { address: hexText(address), size, bytesRead });
+        return bytes.subarray(0, size);
+    }
+}

package/dist/frida-worker.js

@@ -1,85 +1,84 @@
 import { readFile } from "node:fs/promises";
 import { createInterface } from "node:readline";
-import { FridaCommandRuntime } from "./frida-runtime.js";
+import { FridaCommandRuntime } from "./analysis/frida-runtime.js";
 function record(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function requiredPositive(value, name) {
-    const number = typeof value === "number" ? value : Number(value);
+function positive(value, name) {
+    const number = Number(value);
     if (!Number.isSafeInteger(number) || number < 1)
         throw new Error(`${name} must be a positive integer`);
     return number;
 }
-function hex(value, name) {
-    if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0)
-        return `0x${value.toString(16)}`;
-    if (typeof value !== "string" || !/^(?:0x)?[0-9a-f]+$/i.test(value.trim()))
-        throw new Error(`${name} must be hexadecimal`);
-    return `0x${BigInt(value).toString(16)}`;
-}
-function add(base, offset) {
-    return `0x${(BigInt(base) + BigInt(offset)).toString(16)}`;
-}
+/**
+ * Elevated Frida execution boundary. Analysis belongs to the caller-supplied
+ * GumJS source; this process only attaches, loads, calls, and cleans it up.
+ */
 async function run(input) {
-    if (input.command !== "runtime-export")
+    if (input.command !== "dynamic-script")
         throw new Error("unsupported worker command");
-    const pid = requiredPositive(input.pid, "pid");
+    const pid = positive(input.pid, "pid");
     const buildKey = String(input.build ?? input.buildKey ?? "").trim();
     if (!buildKey)
         throw new Error("build is required");
-    const profileFile = typeof input.staticProfile === "string" ? input.staticProfile : undefined;
-    const profile = profileFile ? record(JSON.parse(await readFile(profileFile, "utf8"))) : {};
-    const moduleProfile = record(profile.module);
-    const moduleName = typeof moduleProfile.name === "string" ? moduleProfile.name : "Wow.exe";
+    const source = typeof input.source === "string"
+        ? input.source
+        : typeof input.script === "string" ? await readFile(input.script, "utf8") : "";
+    if (!source.trim())
+        throw new Error("script or source is required");
     const runtime = new FridaCommandRuntime({ artifactDir: process.env.WOW_ANALYZE_DIR });
+    let sessionId;
+    let loaded = false;
     try {
         const attached = await runtime.execute({ operation: "attach", pid, buildKey, allowUnmatched: true });
-        const sessionId = String(attached.sessionId);
+        sessionId = String(attached.sessionId);
         const modules = await runtime.execute({ operation: "modules", sessionId, pid, buildKey });
-        const list = Array.isArray(modules.modules) ? modules.modules : [];
-        const module = list.find(item => String(item.name ?? "").toLowerCase() === moduleName.toLowerCase())
-            ?? list.find(item => String(item.name ?? "").toLowerCase() === "wow.exe");
-        if (!module || typeof module.base !== "string")
-            throw new Error(`${moduleName} module was not found`);
-        const moduleBase = module.base;
-        const moduleSize = Number(module.size ?? 0);
-        const candidates = [
-            ...(Array.isArray(profile.signatures) ? profile.signatures : []),
-            ...(Array.isArray(profile.providers) ? profile.providers : []),
-            ...(Array.isArray(profile.functions) ? profile.functions : [])
-        ].map(record);
-        const limit = Math.min(requiredPositive(input.maxEvents ?? 100, "max-events"), 10000);
-        const records = [];
-        for (const [index, candidate] of candidates.slice(0, limit).entries()) {
-            const rvaValue = candidate.rva;
-            if (rvaValue === undefined)
-                continue;
-            const rva = hex(rvaValue, `profile record ${index}.rva`);
-            const address = add(moduleBase, rva);
-            const size = Math.min(Math.max(Number(candidate.size ?? 16), 1), 256);
-            const read = await runtime.execute({ operation: "read_memory", sessionId, address, size, pid, buildKey });
-            records.push({
-                name: typeof candidate.name === "string" ? candidate.name : `record_${index}`,
-                rva,
-                runtimeAddress: address,
-                bytesHex: read.bytesHex ?? null,
-                source: "frida",
-                confidence: "unverified"
+        const module = Array.isArray(modules.modules)
+            ? modules.modules.find(item => String(item.name ?? "").toLowerCase() === "wow.exe")
+            : undefined;
+        await runtime.execute({
+            operation: "script_load",
+            sessionId,
+            pid,
+            buildKey,
+            source: `globalThis.__WOWDUMP_INPUT__ = Object.freeze(${JSON.stringify(input.args ?? {})});\n${source}`,
+            scriptId: "dynamic"
+        });
+        loaded = true;
+        let value;
+        let messages = [];
+        if (typeof input.exportName === "string" && input.exportName.trim()) {
+            const called = await runtime.execute({
+                operation: "script_call",
+                sessionId,
+                scriptId: "dynamic",
+                exportName: input.exportName,
+                args: Array.isArray(input.callArgs) ? input.callArgs : []
             });
+            value = called.value;
+            messages = Array.isArray(called.messages) ? called.messages : [];
         }
+        const durationMs = Math.min(120_000, positive(input.durationMs ?? 100, "duration-ms"));
+        if (value === undefined)
+            await new Promise(resolve => setTimeout(resolve, durationMs));
         return {
             ok: true,
-            command: "analyze.runtime-export",
+            command: "analyze.dynamic",
             pid,
             buildKey,
-            module: { name: module.name, moduleBase, moduleSize },
-            moduleBase,
-            moduleSize,
-            records,
-            evidence: [{ kind: "frida-runtime-read", source: "frida", moduleBase, count: records.length }]
+            module: module && typeof module.base === "string"
+                ? { name: module.name, moduleBase: module.base, moduleSize: module.size ?? null }
+                : null,
+            exportName: typeof input.exportName === "string" ? input.exportName : null,
+            value,
+            messages,
+            script: typeof input.script === "string" ? input.script : "<inline>",
+            evidence: [{ kind: "frida-gumjs", source: "frida", moduleBase: module?.base ?? null }]
         };
     }
     finally {
+        if (sessionId && loaded)
+            await runtime.execute({ operation: "script_unload", sessionId, scriptId: "dynamic" }).catch(() => undefined);
         await runtime.close();
     }
 }

package/dist/{reader-broker.js → reader/broker.js}

@@ -85,6 +85,7 @@ export class ReaderBroker {
     backend;
     now;
     onShutdown;
+    runFrida;
     handles = new Map();
     watches = new Map();
     idleTimer;
@@ -95,6 +96,7 @@ export class ReaderBroker {
         this.idleTimeoutMs = Math.max(1, Math.floor(options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS));
         this.now = options.now ?? Date.now;
         this.onShutdown = options.onShutdown;
+        this.runFrida = options.runFrida;
         this.armIdleTimer();
     }
     get isStopped() {
@@ -161,6 +163,12 @@ export class ReaderBroker {
                     activeWatches: this.activeWatchCount,
                     elevation: await Promise.resolve(this.backend.elevationStatus?.() ?? { state: "unknown" })
                 };
+            case "frida":
+                if (!this.runFrida)
+                    throw new ReaderProtocolError("FRIDA_NOT_CONFIGURED", "elevated Frida runner is not configured");
+                return this.runFrida(request);
+            case "modules":
+                return this.modules(request);
             case "open":
                 return this.open(request);
             case "close":
@@ -240,6 +248,13 @@ export class ReaderBroker {
             finishedAt: this.now()
         };
     }
+    async modules(request) {
+        const pid = boundedPid(request.pid);
+        if (!this.backend.enumerateModules) {
+            throw new ReaderProtocolError("MODULE_ENUM_UNAVAILABLE", "native module enumeration is not installed");
+        }
+        return { pid, modules: await this.backend.enumerateModules(pid) };
+    }
     async watchStart(request) {
         const pid = boundedPid(request.pid);
         const address = hexAddress(request.address);

package/dist/{reader-client.js → reader/client.js}

@@ -1 +1 @@
-export { ReaderClient, ReaderBrokerPool, ReaderProtocolError, createElevatedLaunchSpec } from "./reader-broker.js";
+export { ReaderClient, ReaderBrokerPool, ReaderProtocolError, createElevatedLaunchSpec } from "./broker.js";

package/dist/{windows-launcher.js → reader/launcher.js}

@@ -3,7 +3,7 @@ import { createConnection } from "node:net";
 import { mkdir, open, readFile, rm } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import koffi from "koffi";
-import { ReaderProtocolError } from "./reader-broker.js";
+import { ReaderProtocolError } from "./broker.js";
 function quoteWindowsArgument(value) {
     if (value.length > 0 && !/[\s"]/u.test(value))
         return value;
@@ -94,7 +94,11 @@ function requestPipe(metadata, request, timeoutMs) {
             else
                 resolveResult(value);
         };
-        const timer = setTimeout(() => finish(new Error(`reader broker request timed out after ${timeoutMs}ms`)), timeoutMs);
+        const timer = setTimeout(() => {
+            const error = new Error(`reader broker request timed out after ${timeoutMs}ms`);
+            error.code = "BROKER_REQUEST_TIMEOUT";
+            finish(error);
+        }, timeoutMs);
         socket.setEncoding("utf8");
         socket.once("connect", () => socket.write(`${JSON.stringify({ token: metadata.token, request })}\n`));
         socket.on("data", chunk => {
@@ -128,10 +132,18 @@ export class WindowsBrokerManager {
         const request = invocationRequest(invocation);
         const existing = await this.readMetadata();
         if (existing) {
+            const requestTimeout = invocation.command === "frida"
+                ? Math.max(this.options.requestTimeoutMs ?? 30_000, Math.min(600_000, Number(invocation.payload.timeoutMs ?? 120_000) + 10_000))
+                : this.options.requestTimeoutMs ?? 30_000;
             try {
-                return await requestPipe(existing, request, this.options.requestTimeoutMs ?? 30_000);
+                return await requestPipe(existing, request, requestTimeout);
             }
-            catch {
+            catch (error) {
+                const code = error.code;
+                // A long-running Frida request is not evidence that the broker died.
+                // Keep its metadata so the next command reuses the elevated process.
+                if (code === "BROKER_REQUEST_TIMEOUT")
+                    throw error;
                 await rm(this.metadataFile, { force: true }).catch(() => undefined);
             }
         }

package/dist/reader/main.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import { createServer } from "node:net";
+import { spawn } from "node:child_process";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { serveReaderBroker } from "./broker.js";
+import { createWindowsNativeReader } from "./windows.js";
+async function runElevatedFrida(request) {
+    const worker = resolve(request.worker);
+    if (!isAbsolute(request.worker) || worker !== request.worker && process.platform === "win32") {
+        throw new Error("Frida worker path must be absolute");
+    }
+    const timeoutMs = Math.max(1, Math.min(Number(request.timeoutMs ?? 120_000), 600_000));
+    return new Promise(resolveResult => {
+        const child = spawn(process.execPath, [worker], { windowsHide: true, stdio: ["pipe", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const finish = (exitCode, timedOut = false) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolveResult({ exitCode, stdout, stderr, timedOut });
+        };
+        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 => { stderr += error.message; finish(1); });
+        child.once("exit", code => finish(code ?? 1));
+        const timer = setTimeout(() => {
+            child.kill();
+            finish(1, true);
+        }, timeoutMs);
+        child.stdin.end(request.input);
+    });
+}
+function argument(name) {
+    const index = process.argv.indexOf(name);
+    return index >= 0 ? process.argv[index + 1] : undefined;
+}
+const listen = argument("--listen");
+const port = Number(argument("--port") ?? "0");
+const token = argument("--token");
+const metadata = argument("--metadata");
+let server;
+const broker = serveReaderBroker({
+    attachStdio: !listen,
+    backend: process.env.WOWDUMP_USE_FAKE_READER === "1" ? undefined : createWindowsNativeReader(),
+    runFrida: runElevatedFrida,
+    onShutdown: async () => {
+        server?.close();
+        if (metadata)
+            await rm(metadata, { force: true }).catch(() => undefined);
+    }
+});
+if (listen) {
+    if (listen !== "127.0.0.1" || !token || !metadata || !Number.isSafeInteger(port) || port < 0 || port > 65535) {
+        throw new Error("--listen requires 127.0.0.1, a valid --port, --token and --metadata");
+    }
+    server = createServer(socket => {
+        socket.setEncoding("utf8");
+        let buffer = "";
+        let pending = Promise.resolve();
+        socket.on("data", chunk => {
+            buffer += chunk;
+            while (buffer.includes("\n")) {
+                const newline = buffer.indexOf("\n");
+                const line = buffer.slice(0, newline);
+                buffer = buffer.slice(newline + 1);
+                pending = pending.then(async () => {
+                    try {
+                        const envelope = JSON.parse(line);
+                        if (envelope.token !== token || !envelope.request) {
+                            socket.write(`${JSON.stringify({ ok: false, command: "auth", timestamp: Date.now(), error: { code: "AUTH_FAILED", message: "invalid reader broker token" } })}\n`);
+                            return;
+                        }
+                        socket.write(`${JSON.stringify(await broker.handle(envelope.request))}\n`);
+                    }
+                    catch (error) {
+                        socket.write(`${JSON.stringify({ ok: false, command: "parse", timestamp: Date.now(), error: { code: "INVALID_JSON", message: error instanceof Error ? error.message : String(error) } })}\n`);
+                    }
+                });
+            }
+        });
+    });
+    server.listen(port, listen, async () => {
+        await mkdir(dirname(metadata), { recursive: true });
+        const address = server?.address();
+        if (!address || typeof address === "string")
+            throw new Error("reader broker did not acquire a TCP endpoint");
+        await writeFile(metadata, `${JSON.stringify({ schema: "wowdump.reader-broker.v1", host: listen, port: address.port, token, pid: process.pid })}\n`, { encoding: "utf8", mode: 0o600 });
+    });
+}
+const shutdown = () => {
+    void broker.shutdown("request").catch(() => process.exitCode = 1);
+};
+process.once("SIGINT", shutdown);
+process.once("SIGTERM", shutdown);

package/dist/reader/protocol.js

@@ -0,0 +1 @@
+export {};