wowdump 0.0.0 → 0.2.1

package/dist/session.js

@@ -0,0 +1,145 @@
+import { readFile } from "node:fs/promises";
+import { ErrorEventSchema } from "./types.js";
+import { brokerManagedCommand } from "./frida-runtime.js";
+export class ProcessSession {
+    process;
+    agentFile;
+    store;
+    executor;
+    messagePollMs;
+    sessionId;
+    scriptId;
+    messageCursor = 0;
+    pollTimer;
+    polling;
+    constructor(process, agentFile, store, executor, messagePollMs = 250) {
+        this.process = process;
+        this.agentFile = agentFile;
+        this.store = store;
+        this.executor = executor;
+        this.messagePollMs = messagePollMs;
+    }
+    async attach() {
+        if (this.sessionId)
+            return;
+        const context = this.context();
+        const attached = await this.executor.execute({
+            operation: "attach",
+            pid: this.process.pid,
+            buildKey: context.buildKey
+        }, context);
+        this.sessionId = requiredString(attached.sessionId, "attach.sessionId");
+        const source = await readFile(this.agentFile, "utf8");
+        try {
+            const loaded = await this.executor.execute(brokerManagedCommand({
+                operation: "script_load",
+                sessionId: this.sessionId,
+                pid: this.process.pid,
+                buildKey: context.buildKey,
+                source
+            }, "collector.script_load"), context);
+            this.scriptId = requiredString(loaded.scriptId, "script_load.scriptId");
+            await this.pollMessages();
+            this.pollTimer = setInterval(() => {
+                void this.pollMessages().catch(() => undefined);
+            }, this.messagePollMs);
+            this.pollTimer.unref?.();
+        }
+        catch (error) {
+            await this.detach();
+            throw error;
+        }
+    }
+    async detach() {
+        if (this.pollTimer)
+            clearInterval(this.pollTimer);
+        this.pollTimer = undefined;
+        await this.polling?.catch(() => undefined);
+        await this.pollMessages().catch(() => undefined);
+        const context = this.context();
+        const scriptId = this.scriptId;
+        const sessionId = this.sessionId;
+        this.scriptId = undefined;
+        this.sessionId = undefined;
+        if (scriptId && sessionId) {
+            await this.executor.execute(brokerManagedCommand({
+                operation: "script_unload",
+                pid: this.process.pid,
+                buildKey: context.buildKey,
+                sessionId,
+                scriptId
+            }, "collector.script_unload"), context).catch(() => undefined);
+        }
+        if (sessionId) {
+            await this.executor.execute({
+                operation: "detach",
+                pid: this.process.pid,
+                buildKey: context.buildKey,
+                sessionId
+            }, context).catch(() => undefined);
+        }
+        this.messageCursor = 0;
+    }
+    async pollMessages() {
+        if (this.polling)
+            return this.polling;
+        if (!this.sessionId || !this.scriptId)
+            return;
+        this.polling = this.readMessages();
+        try {
+            await this.polling;
+        }
+        finally {
+            this.polling = undefined;
+        }
+    }
+    async readMessages() {
+        const sessionId = this.sessionId;
+        const scriptId = this.scriptId;
+        if (!sessionId || !scriptId)
+            return;
+        const result = await this.executor.execute(brokerManagedCommand({
+            operation: "script_call",
+            pid: this.process.pid,
+            buildKey: this.process.install.build.buildKey,
+            sessionId,
+            scriptId,
+            exportName: "collectorStatus"
+        }, "collector.status"), this.context());
+        const messages = Array.isArray(result.messages) ? result.messages : [];
+        for (const item of messages.slice(this.messageCursor)) {
+            const message = asRecord(asRecord(item).message);
+            if (message.type !== "send")
+                continue;
+            const payload = asRecord(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);
+        }
+        this.messageCursor = messages.length;
+    }
+    context() {
+        return {
+            pid: this.process.pid,
+            buildKey: this.process.install.build.buildKey,
+            flavor: this.process.install.flavor,
+            executable: this.process.executable,
+            processStartTime: this.process.startTime
+        };
+    }
+}
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function requiredString(value, field) {
+    if (typeof value !== "string" || value.length === 0)
+        throw new Error(`${field} is required`);
+    return value;
+}

package/dist/storage.js

@@ -0,0 +1,12 @@
+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/types.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+export const ObservationTierSchema = z.enum([
+    "error_text",
+    "source_location",
+    "stack_trace",
+    "vm_metadata"
+]);
+export const AgentReadyEventSchema = z.object({
+    schema: z.literal(1),
+    type: z.literal("agent_ready"),
+    semanticReadOnly: z.literal(true),
+    observationTiers: z.array(ObservationTierSchema)
+});
+export const ErrorEventSchema = z.object({
+    schema: z.literal(1),
+    type: z.literal("lua_error"),
+    timestamp: z.number(),
+    pid: z.number(),
+    threadId: z.number().optional(),
+    buildKey: z.string(),
+    flavor: z.string(),
+    addon: z.string().optional(),
+    message: z.string(),
+    stack: z.string().optional(),
+    sourceAddress: z.string().optional()
+});