wowdump 0.3.4 → 0.3.7

package/dist/analysis/frida-runtime.js

@@ -1,715 +0,0 @@
-import { createHash } from "node:crypto";
-import { appendFile, mkdir } from "node:fs/promises";
-import { join } from "node:path";
-const DEFAULT_MAX_SOURCE_BYTES = 4 * 1024 * 1024;
-const DEFAULT_MAX_MEMORY_BYTES = 16 * 1024 * 1024;
-const DEFAULT_SCRIPT_TIMEOUT_MS = 150;
-/*
- * This is deliberately a small, stable RPC facade over GumJS.  `script` and
- * `script_load` still accept native GumJS, so a new WoW build can use any
- * Frida API without requiring a host release for every new command.
- */
-const BRIDGE_SOURCE = String.raw `
-function __wowBytes(value) {
-  return value == null ? [] : Array.from(new Uint8Array(value));
-}
-function __wowModule(value) {
-  return { name: value.name, base: value.base.toString(), size: value.size, path: value.path };
-}
-function __wowExport(value) {
-  return { type: value.type, name: value.name, address: value.address.toString(), moduleName: value.moduleName };
-}
-function __wowRange(value) {
-  return { base: value.base.toString(), size: value.size, protection: value.protection, file: value.file ?? null };
-}
-rpc.exports = {
-  enumerateModules() {
-    return Process.enumerateModules().map(__wowModule);
-  },
-  enumerateExports(moduleName) {
-    const module = Process.getModuleByName(moduleName);
-    return module.enumerateExports().map(__wowExport);
-  },
-  enumerateRanges(protection, coalesce) {
-    try {
-      return Process.enumerateRanges({ protection: protection || "r--", coalesce: Boolean(coalesce) }).map(__wowRange);
-    } catch (_) {
-      return Process.enumerateRanges(protection || "r--").map(__wowRange);
-    }
-  },
-  readMemory(address, size) {
-    return __wowBytes(ptr(address).readByteArray(size));
-  },
-  writeMemory(address, bytes) {
-    const target = ptr(address);
-    const input = Uint8Array.from(bytes || []);
-    const before = __wowBytes(target.readByteArray(input.byteLength));
-    target.writeByteArray(input.buffer);
-    return { before, after: Array.from(input), address: target.toString(), size: input.byteLength };
-  },
-  protectMemory(address, size, protection) {
-    const changed = Memory.protect(ptr(address), size, protection);
-    return { address: ptr(address).toString(), size, protection, changed };
-  },
-  scanMemory(address, size, pattern) {
-    return Memory.scanSync(ptr(address), size, pattern).map(match => ({
-      address: match.address.toString(), size: match.size
-    }));
-  }
-};
-`;
-function asRecord(value) {
-    return value && typeof value === "object" ? value : {};
-}
-function normalize(value, seen = new WeakSet(), depth = 0) {
-    if (value === undefined || value === null)
-        return value;
-    if (typeof value === "bigint")
-        return value.toString();
-    if (Buffer.isBuffer(value))
-        return value.toString("hex");
-    if (value instanceof ArrayBuffer)
-        return Buffer.from(new Uint8Array(value)).toString("hex");
-    if (ArrayBuffer.isView(value)) {
-        return Buffer.from(value.buffer, value.byteOffset, value.byteLength).toString("hex");
-    }
-    if (depth > 8)
-        return "[MaxDepth]";
-    if (typeof value === "object") {
-        if (seen.has(value))
-            return "[Circular]";
-        seen.add(value);
-    }
-    if (Array.isArray(value))
-        return value.map(item => normalize(item, seen, depth + 1));
-    if (typeof value === "object") {
-        const output = {};
-        for (const [key, item] of Object.entries(value))
-            output[key] = normalize(item, seen, depth + 1);
-        return output;
-    }
-    return value;
-}
-function redactArtifact(value, key = "") {
-    if (typeof value === "string") {
-        const looksLikePath = /^(?:[a-zA-Z]:[\\/]|\\\\|\/)/.test(value);
-        const looksLikeBytes = /(?:hex|bytes)$/i.test(key) && value.length > 32;
-        const looksLikeHexBlob = value.length > 256 && value.length % 2 === 0 && /^[0-9a-f]+$/i.test(value);
-        if (looksLikeHexBlob)
-            return { sha256: hash(value), bytes: value.length / 2, encoding: "hex" };
-        if (looksLikePath || looksLikeBytes)
-            return { sha256: hash(value), bytes: Buffer.byteLength(value, "utf8") };
-        return value;
-    }
-    if (Array.isArray(value))
-        return value.map(item => redactArtifact(item, key));
-    if (value && typeof value === "object") {
-        const output = {};
-        for (const [childKey, childValue] of Object.entries(value))
-            output[childKey] = redactArtifact(childValue, childKey);
-        return output;
-    }
-    return value;
-}
-function decodeHostArg(value) {
-    if (Array.isArray(value))
-        return value.map(item => decodeHostArg(item));
-    if (value && typeof value === "object") {
-        const record = value;
-        if (typeof record.__bufferHex === "string")
-            return Buffer.from(parseHex(record.__bufferHex, "__bufferHex", DEFAULT_MAX_MEMORY_BYTES));
-        const output = {};
-        for (const [key, item] of Object.entries(record))
-            output[key] = decodeHostArg(item);
-        return output;
-    }
-    return value;
-}
-function requirePositiveInteger(value, field) {
-    if (!Number.isSafeInteger(value) || value === undefined || value < 1) {
-        throw new Error(`${field} must be a positive integer`);
-    }
-    return value;
-}
-function requireString(value, field) {
-    if (typeof value !== "string" || value.trim() === "")
-        throw new Error(`${field} is required`);
-    return value;
-}
-function parseHex(value, field, maxBytes) {
-    const text = requireString(value, field).replace(/^0x/i, "");
-    if (!text || !/^[0-9a-f]+$/i.test(text) || text.length % 2 !== 0) {
-        throw new Error(`${field} must be an even-length hexadecimal string`);
-    }
-    if (text.length / 2 > maxBytes)
-        throw new Error(`${field} exceeds the memory limit`);
-    const bytes = [];
-    for (let index = 0; index < text.length; index += 2)
-        bytes.push(Number.parseInt(text.slice(index, index + 2), 16));
-    return bytes;
-}
-function pointer(value) {
-    if (typeof value === "number") {
-        if (!Number.isSafeInteger(value) || value < 0)
-            throw new Error("address must be a non-negative hexadecimal pointer");
-        return `0x${value.toString(16)}`;
-    }
-    if (typeof value === "bigint") {
-        if (value < 0n)
-            throw new Error("address must be a non-negative hexadecimal pointer");
-        return `0x${value.toString(16)}`;
-    }
-    const text = requireString(value, "address").trim();
-    if (!/^(?:0x)?[0-9a-f]+$/i.test(text))
-        throw new Error("address must be a hexadecimal pointer");
-    return text;
-}
-function protection(value) {
-    const text = requireString(value, "protection").trim();
-    if (!/^[rwx-]{3}$/.test(text))
-        throw new Error("protection must contain three characters from r, w, x, or -");
-    return text;
-}
-function hash(value) {
-    return createHash("sha256").update(value).digest("hex").slice(0, 16);
-}
-function exportFunction(script, name) {
-    const exports = script.exports ?? {};
-    const candidate = exports[name] ?? exports[name.toLowerCase()];
-    if (typeof candidate !== "function")
-        throw new Error(`script export ${name} was not found`);
-    return candidate;
-}
-function buildPrelude(context) {
-    const payload = JSON.stringify({
-        pid: context?.pid,
-        buildKey: context?.buildKey,
-        flavor: context?.flavor,
-        executable: context?.executable,
-        adapter: context?.adapter
-    });
-    const verifiedPrelude = context?.adapter?.adapter?.fridaPrelude ?? "";
-    return `${verifiedPrelude}\nglobalThis.__WOW_BUILD_CONTEXT__ = Object.freeze(${payload});`;
-}
-/** Merge caller-supplied request fields with the resolver context. */
-function requestContext(request, context, existing) {
-    return {
-        ...(existing ?? {}),
-        ...(context ?? {}),
-        ...(request.pid === undefined ? {} : { pid: request.pid }),
-        ...(request.buildKey === undefined ? {} : { buildKey: request.buildKey }),
-        ...(request.flavor === undefined ? {} : { flavor: request.flavor }),
-        ...(request.adapter === undefined ? {} : { adapter: request.adapter }),
-        ...(request.executable === undefined ? {} : { executable: request.executable })
-    };
-}
-function sessionContext(record) {
-    const context = normalize(record.context);
-    return {
-        pid: record.pid,
-        ...(context.buildKey === undefined ? {} : { buildKey: context.buildKey }),
-        ...(context.flavor === undefined ? {} : { flavor: context.flavor }),
-        ...(context.adapter === undefined ? {} : { adapter: context.adapter }),
-        ...(context.executable === undefined ? {} : { executable: context.executable })
-    };
-}
-function serializeDevice(device) {
-    return { id: device.id, name: device.name, type: normalize(device.type) };
-}
-function serializeProcess(process) {
-    return { pid: process.pid, name: process.name, parameters: normalize(process.parameters) };
-}
-function serializeApplication(application) {
-    return {
-        identifier: application.identifier,
-        name: application.name,
-        pid: application.pid,
-        parameters: normalize(application.parameters)
-    };
-}
-export class FridaCommandRuntime {
-    sessions = new Map();
-    scripts = new Map();
-    apiOverride;
-    loaderOverride;
-    artifactDir;
-    maxSourceBytes;
-    maxMemoryBytes;
-    apiPromise;
-    sessionCounter = 0;
-    scriptCounter = 0;
-    constructor(optionsOrApi = {}) {
-        const candidate = optionsOrApi;
-        const looksLikeApi = [candidate.enumerateDevices, candidate.enumerateProcesses, candidate.getLocalDevice, candidate.getDevice, candidate.attach]
-            .some(value => typeof value === "function")
-            && !("api" in optionsOrApi);
-        const options = looksLikeApi ? {} : optionsOrApi;
-        this.apiOverride = looksLikeApi ? optionsOrApi : options.api ?? options.fridaApi ?? options.frida;
-        this.loaderOverride = options.loader ?? options.loadFrida;
-        this.artifactDir = options.artifactDir;
-        this.maxSourceBytes = options.maxSourceBytes ?? DEFAULT_MAX_SOURCE_BYTES;
-        this.maxMemoryBytes = options.maxMemoryBytes ?? DEFAULT_MAX_MEMORY_BYTES;
-        if (!Number.isSafeInteger(this.maxSourceBytes) || this.maxSourceBytes < 1) {
-            throw new TypeError("maxSourceBytes must be a positive safe integer");
-        }
-        if (!Number.isSafeInteger(this.maxMemoryBytes) || this.maxMemoryBytes < 1) {
-            throw new TypeError("maxMemoryBytes must be a positive safe integer");
-        }
-    }
-    async execute(request, context) {
-        const operation = request?.operation ?? request?.op ?? request?.command;
-        if (typeof operation !== "string" || !operation.trim())
-            throw new Error("operation is required");
-        if (request.pid !== undefined)
-            requirePositiveInteger(request.pid, "pid");
-        const effectiveContext = requestContext(request, context);
-        const hasContext = Object.keys(effectiveContext).length > 0;
-        const result = await this.dispatch({ ...request, operation: operation }, hasContext ? effectiveContext : undefined);
-        const enriched = {
-            operation,
-            ...(hasContext ? { target: normalize(effectiveContext) } : {}),
-            ...result
-        };
-        await this.record(request, hasContext ? effectiveContext : undefined, enriched);
-        return enriched;
-    }
-    async close() {
-        for (const scriptId of [...this.scripts.keys()]) {
-            await this.unloadScript(scriptId).catch(() => undefined);
-        }
-        for (const sessionId of [...this.sessions.keys()]) {
-            await this.detachSession(sessionId).catch(() => undefined);
-        }
-    }
-    /**
-     * Run a caller-supplied export while forwarding Frida binary messages to a
-     * consumer. Runtime dump uses this path so ArrayBuffers never become JSON.
-     */
-    async streamScriptCall(request, context, handler, callArgs = []) {
-        const record = await this.session(request, context);
-        const source = this.source(request.source);
-        const script = await record.session.createScript(buildPrelude(context ?? record.context) + "\n" + source, request.options);
-        let pending = Promise.resolve();
-        script.message?.connect((message, data) => {
-            pending = pending.then(() => handler(message, data));
-        });
-        await script.load();
-        try {
-            const name = requireString(request.exportName ?? request.method, "exportName");
-            const value = await exportFunction(script, name)(...callArgs.map(item => decodeHostArg(item)));
-            await pending;
-            return { sessionId: record.id, value: normalize(value), ...sessionContext(record) };
-        }
-        finally {
-            try {
-                await script.unload();
-            }
-            catch { /* cleanup is best effort */ }
-        }
-    }
-    async api() {
-        if (this.apiOverride)
-            return this.apiOverride;
-        this.apiPromise ??= Promise.resolve(this.loaderOverride ? this.loaderOverride() : import("frida")).then(module => {
-            const candidate = module.default;
-            return candidate ?? module;
-        });
-        return this.apiPromise;
-    }
-    async device(id) {
-        const api = await this.api();
-        const getDevice = api.getDevice;
-        const getLocalDevice = api.getLocalDevice;
-        if (id && getDevice) {
-            const device = await getDevice(id);
-            if (!device)
-                throw new Error(`Frida device ${id} was not found`);
-            return device;
-        }
-        if (!id && getLocalDevice) {
-            const device = await getLocalDevice();
-            if (!device)
-                throw new Error("Frida local device was not found");
-            return device;
-        }
-        if (typeof api.enumerateDevices !== "function")
-            throw new Error("Frida device enumeration is not available");
-        const devices = await api.enumerateDevices();
-        const wanted = id ?? "local";
-        const device = devices.find(item => item.id === wanted) ?? (id ? undefined : devices[0]);
-        if (!device)
-            throw new Error(`Frida device ${wanted} was not found`);
-        return device;
-    }
-    async dispatch(request, context) {
-        switch (request.operation) {
-            case "devices": {
-                const enumerateDevices = (await this.api()).enumerateDevices;
-                if (!enumerateDevices)
-                    throw new Error("Frida device enumeration is not available");
-                const devices = await enumerateDevices();
-                return { devices: devices.map(serializeDevice) };
-            }
-            case "host_call":
-                return this.hostCall(request, context);
-            case "processes": {
-                const device = await this.device(request.deviceId);
-                const api = await this.api();
-                const processes = device.enumerateProcesses
-                    ? await device.enumerateProcesses(request.options)
-                    : api.enumerateProcesses
-                        ? await api.enumerateProcesses(request.options)
-                        : (() => { throw new Error("Frida process enumeration is not available"); })();
-                return { device: serializeDevice(device), processes: processes.map(serializeProcess) };
-            }
-            case "applications": {
-                const device = await this.device(request.deviceId);
-                if (!device.enumerateApplications)
-                    throw new Error("this Frida device does not support application enumeration");
-                const applications = await device.enumerateApplications(request.options);
-                return { device: serializeDevice(device), applications: applications.map(serializeApplication) };
-            }
-            case "spawn": {
-                const device = await this.device(request.deviceId);
-                const program = request.argv && request.argv.length > 0 ? request.argv : requireString(request.program, "program");
-                if (!device.spawn)
-                    throw new Error("this Frida device does not support spawn");
-                const pid = await device.spawn(program, request.options);
-                return { device: serializeDevice(device), pid };
-            }
-            case "resume":
-                return { pid: await this.requirePid(request, context), resumed: await this.resume(request, context) };
-            case "kill":
-                return { pid: await this.requirePid(request, context), killed: await this.kill(request, context) };
-            case "attach":
-                return this.attach(request, context);
-            case "detach":
-                return this.detach(request, context);
-            case "session_status":
-                return { sessions: [...this.sessions.values()].map(item => ({ id: item.id, pid: item.pid, device: serializeDevice(item.device), scripts: [...item.scripts.keys()], ...sessionContext(item) })) };
-            case "modules":
-                return this.namedBridgeCall(request, context, "enumerateModules", [], "modules");
-            case "exports":
-                return this.namedBridgeCall(request, context, "enumerateExports", [requireString(request.module, "module")], "exports");
-            case "ranges":
-                return this.namedBridgeCall(request, context, "enumerateRanges", [request.protection ?? "r--", request.coalesce ?? false], "ranges");
-            case "read_memory": {
-                const size = requirePositiveInteger(request.size, "size");
-                if (size > this.maxMemoryBytes)
-                    throw new Error("size exceeds the memory limit");
-                const response = await this.bridgeCall(request, context, "readMemory", [pointer(request.address), size]);
-                const value = response.value;
-                const bytes = Array.isArray(value) ? value : asRecord(value).bytes instanceof Array ? asRecord(value).bytes : [];
-                const bytesHex = Buffer.from(bytes).toString("hex");
-                return { ...response, address: pointer(request.address), size: bytes.length, bytesHex, hex: bytesHex };
-            }
-            case "write_memory": {
-                const bytes = parseHex(request.bytesHex ?? request.hex, "bytesHex", this.maxMemoryBytes);
-                const response = await this.bridgeCall(request, context, "writeMemory", [pointer(request.address), bytes]);
-                const record = asRecord(response.value);
-                const beforeHex = Array.isArray(record.before) ? Buffer.from(record.before).toString("hex") : undefined;
-                const afterHex = Array.isArray(record.after) ? Buffer.from(record.after).toString("hex") : Buffer.from(bytes).toString("hex");
-                return {
-                    ...response,
-                    address: record.address ?? pointer(request.address),
-                    size: bytes.length,
-                    beforeHex,
-                    afterHex,
-                    hex: afterHex,
-                    rollback: beforeHex
-                        ? { operation: "write_memory", address: record.address ?? request.address, bytesHex: beforeHex }
-                        : undefined
-                };
-            }
-            case "protect_memory": {
-                const size = requirePositiveInteger(request.size, "size");
-                if (size > this.maxMemoryBytes)
-                    throw new Error("size exceeds the memory limit");
-                return this.bridgeCall(request, context, "protectMemory", [pointer(request.address), size, protection(request.protection)]);
-            }
-            case "scan_memory": {
-                const size = requirePositiveInteger(request.size, "size");
-                if (size > this.maxMemoryBytes)
-                    throw new Error("size exceeds the memory limit");
-                return this.bridgeCall(request, context, "scanMemory", [pointer(request.address), size, requireString(request.pattern, "pattern")]);
-            }
-            case "script_load":
-                return this.loadScript(request, context);
-            case "script_call":
-                return this.callScript(request);
-            case "script_unload":
-                return this.unloadScriptResult(request, context);
-            case "script":
-                return request.persist ? this.loadScript(request, context) : this.runTransientScript(request, context);
-            case "compile_script": {
-                const source = this.source(request.source);
-                const record = await this.session(request, context);
-                if (!record.session.compileScript)
-                    throw new Error("this Frida session does not support compileScript");
-                const bytes = await record.session.compileScript(buildPrelude(context ?? record.context) + "\n" + source, request.options);
-                return { sessionId: record.id, bytesHex: Buffer.from(bytes).toString("hex"), size: bytes.length };
-            }
-            default:
-                throw new Error(`unsupported Frida operation: ${String(request.operation)}`);
-        }
-    }
-    async attach(request, context) {
-        const pid = await this.requirePid(request, context);
-        const device = await this.device(request.deviceId);
-        const existing = [...this.sessions.values()].find(item => item.pid === pid && item.device.id === device.id);
-        const targetContext = requestContext(request, context, existing?.context);
-        if (existing) {
-            existing.context = targetContext;
-            return {
-                sessionId: existing.id,
-                pid,
-                device: serializeDevice(device),
-                reused: true,
-                ...sessionContext(existing)
-            };
-        }
-        const api = await this.api();
-        const session = device.attach
-            ? await device.attach(pid)
-            : api.attach
-                ? await api.attach(pid)
-                : (() => { throw new Error("Frida attach is not available"); })();
-        const record = {
-            id: `session-${++this.sessionCounter}`,
-            device,
-            session,
-            pid,
-            context: targetContext,
-            scripts: new Map(),
-            messages: new Map()
-        };
-        this.sessions.set(record.id, record);
-        return { sessionId: record.id, pid, device: serializeDevice(device), ...sessionContext(record) };
-    }
-    async hostCall(request, context) {
-        const scope = requireString(request.scope, "scope");
-        const method = requireString(request.method, "method");
-        let receiver;
-        if (scope === "api") {
-            receiver = await this.api();
-        }
-        else if (scope === "device") {
-            receiver = await this.device(request.deviceId);
-        }
-        else if (scope === "session") {
-            const record = await this.session(request, context);
-            receiver = record.session;
-        }
-        else {
-            throw new Error("scope must be api, device, or session");
-        }
-        const callable = receiver[method];
-        if (typeof callable !== "function")
-            throw new Error(`${scope}.${method} is not a callable Frida method`);
-        const value = await callable.apply(receiver, (request.args ?? []).map(decodeHostArg));
-        return { scope, method, value: normalize(value) };
-    }
-    async detach(request, context) {
-        const id = request.sessionId ?? [...this.sessions.values()].find(item => item.pid === (request.pid ?? context?.pid))?.id;
-        if (!id)
-            throw new Error("sessionId or pid is required");
-        const record = this.sessions.get(id);
-        await this.detachSession(id);
-        return { sessionId: id, detached: true, ...(record ? sessionContext(record) : {}) };
-    }
-    async detachSession(id) {
-        const record = this.sessions.get(id);
-        if (!record)
-            throw new Error(`session ${id} was not found`);
-        for (const scriptId of [...record.scripts.keys()])
-            await this.unloadScript(scriptId).catch(() => undefined);
-        try {
-            await record.bridge?.unload();
-        }
-        catch { /* bridge cleanup is best effort */ }
-        await record.session.detach();
-        this.sessions.delete(id);
-    }
-    async resume(request, context) {
-        const pid = this.requirePid(request, context);
-        const api = await this.api();
-        if (api.resume) {
-            await api.resume(pid);
-            return true;
-        }
-        const device = await this.device(request.deviceId);
-        if (!device.resume)
-            throw new Error("Frida resume is not available");
-        await device.resume(pid);
-        return true;
-    }
-    async kill(request, context) {
-        const pid = this.requirePid(request, context);
-        const api = await this.api();
-        if (api.kill) {
-            await api.kill(pid);
-            return true;
-        }
-        const device = await this.device(request.deviceId);
-        if (!device.kill)
-            throw new Error("Frida kill is not available");
-        await device.kill(pid);
-        return true;
-    }
-    requirePid(request, context) {
-        return requirePositiveInteger(request.pid ?? context?.pid, "pid");
-    }
-    source(value) {
-        const source = requireString(value, "source");
-        if (Buffer.byteLength(source, "utf8") > this.maxSourceBytes)
-            throw new Error("source exceeds the script size limit");
-        return source;
-    }
-    async session(request, context) {
-        if (request.sessionId) {
-            const record = this.sessions.get(request.sessionId);
-            if (!record)
-                throw new Error(`session ${request.sessionId} was not found`);
-            record.context = requestContext(request, context, record.context);
-            return record;
-        }
-        const pid = this.requirePid(request, context);
-        const device = await this.device(request.deviceId);
-        const existing = [...this.sessions.values()].find(item => item.pid === pid && item.device.id === device.id);
-        if (existing) {
-            existing.context = requestContext(request, context, existing.context);
-            return existing;
-        }
-        const attached = await this.attach({ ...request, operation: "attach", pid }, context);
-        const id = String(attached.sessionId);
-        const record = this.sessions.get(id);
-        if (!record)
-            throw new Error("Frida session was not created");
-        return record;
-    }
-    async bridge(record, context) {
-        if (!record.bridge) {
-            record.bridge = await record.session.createScript(buildPrelude(context ?? record.context) + "\n" + BRIDGE_SOURCE);
-            await record.bridge.load();
-        }
-        return record.bridge;
-    }
-    async bridgeCall(request, context, name, args) {
-        const record = await this.session(request, context);
-        const script = await this.bridge(record, context);
-        const fn = exportFunction(script, name);
-        const value = await fn(...args);
-        return { sessionId: record.id, value: normalize(value), ...sessionContext(record) };
-    }
-    async namedBridgeCall(request, context, name, args, resultKey) {
-        const response = await this.bridgeCall(request, context, name, args);
-        return { ...response, [resultKey]: response.value };
-    }
-    async loadScript(request, context) {
-        const record = await this.session(request, context);
-        const source = this.source(request.source);
-        const script = await record.session.createScript(buildPrelude(context ?? record.context) + "\n" + source, request.options);
-        const requestedId = request.scriptId === undefined ? undefined : requireString(request.scriptId, "scriptId");
-        const id = requestedId ?? `script-${++this.scriptCounter}`;
-        if (this.scripts.has(id))
-            throw new Error(`script ${id} already exists`);
-        const messages = [];
-        script.message?.connect((message, data) => {
-            messages.push({ message: normalize(message), dataHex: data ? data.toString("hex") : undefined });
-        });
-        await script.load();
-        record.scripts.set(id, script);
-        record.messages.set(id, messages);
-        this.scripts.set(id, { session: record, script });
-        return { scriptId: id, sessionId: record.id, loaded: true, ...sessionContext(record) };
-    }
-    async callScript(request) {
-        const id = requireString(request.scriptId, "scriptId");
-        const entry = this.scripts.get(id);
-        if (!entry)
-            throw new Error(`script ${id} was not found`);
-        const name = requireString(request.exportName ?? request.method, "exportName");
-        const value = await exportFunction(entry.script, name)(...(request.args ?? []).map(item => decodeHostArg(item)));
-        return { scriptId: id, value: normalize(value), messages: normalize(entry.session.messages.get(id) ?? []), ...sessionContext(entry.session) };
-    }
-    async unloadScriptResult(request, _context) {
-        const id = requireString(request.scriptId, "scriptId");
-        const entry = this.scripts.get(id);
-        if (!entry)
-            throw new Error(`script ${id} was not found`);
-        const context = sessionContext(entry.session);
-        const unloaded = await this.unloadScript(id);
-        return { scriptId: id, unloaded, ...context };
-    }
-    async unloadScript(id) {
-        const entry = this.scripts.get(id);
-        if (!entry)
-            throw new Error(`script ${id} was not found`);
-        await entry.script.unload();
-        entry.session.scripts.delete(id);
-        entry.session.messages.delete(id);
-        this.scripts.delete(id);
-        return true;
-    }
-    async runTransientScript(request, context) {
-        const record = await this.session(request, context);
-        const source = this.source(request.source);
-        const script = await record.session.createScript(buildPrelude(context ?? record.context) + "\n" + source, request.options);
-        const messages = [];
-        script.message?.connect((message, data) => {
-            messages.push({ message: normalize(message), dataHex: data ? data.toString("hex") : undefined });
-        });
-        await script.load();
-        const timeoutMs = Math.max(1, Math.min(request.timeoutMs ?? DEFAULT_SCRIPT_TIMEOUT_MS, 120000));
-        await new Promise(resolve => setTimeout(resolve, timeoutMs));
-        try {
-            await script.unload();
-        }
-        catch { /* transient cleanup is best effort */ }
-        return { sessionId: record.id, messages: normalize(messages), ...sessionContext(record) };
-    }
-    async record(request, context, result) {
-        if (!this.artifactDir)
-            return;
-        const redactedRequest = { ...request };
-        if (typeof redactedRequest.source === "string") {
-            redactedRequest.source = { sha256: hash(redactedRequest.source), bytes: Buffer.byteLength(redactedRequest.source, "utf8") };
-        }
-        if (typeof redactedRequest.bytesHex === "string") {
-            redactedRequest.bytesHex = { sha256: hash(redactedRequest.bytesHex), bytes: redactedRequest.bytesHex.length / 2 };
-        }
-        if (typeof redactedRequest.hex === "string") {
-            redactedRequest.hex = { sha256: hash(redactedRequest.hex), bytes: redactedRequest.hex.length / 2 };
-        }
-        if (typeof redactedRequest.program === "string") {
-            redactedRequest.program = { sha256: hash(redactedRequest.program), bytes: Buffer.byteLength(redactedRequest.program, "utf8") };
-        }
-        if (Array.isArray(redactedRequest.argv)) {
-            redactedRequest.argv = redactedRequest.argv.map(value => typeof value === "string"
-                ? { sha256: hash(value), bytes: Buffer.byteLength(value, "utf8") }
-                : value);
-        }
-        if (Array.isArray(redactedRequest.args)) {
-            redactedRequest.args = { count: redactedRequest.args.length };
-        }
-        if (redactedRequest.options && typeof redactedRequest.options === "object") {
-            redactedRequest.options = { keys: Object.keys(redactedRequest.options) };
-        }
-        const redactedContext = context
-            ? {
-                ...context,
-                executable: context.executable
-                    ? { sha256: hash(context.executable), bytes: Buffer.byteLength(context.executable, "utf8") }
-                    : undefined
-            }
-            : undefined;
-        const record = {
-            timestamp: new Date().toISOString(),
-            request: redactedRequest,
-            target: redactedContext ? normalize(redactedContext) : undefined,
-            result: redactArtifact(normalize(result))
-        };
-        await mkdir(this.artifactDir, { recursive: true });
-        await appendFile(join(this.artifactDir, "frida-commands.jsonl"), JSON.stringify(record) + "\n", "utf8");
-    }
-}