wowdump 0.2.1 → 0.3.1

package/dist/session.js

@@ -1,117 +1,27 @@
 import { readFile } from "node:fs/promises";
+import * as frida from "frida";
 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) {
+    session;
+    script;
+    constructor(process, agentFile, store) {
         this.process = process;
         this.agentFile = agentFile;
         this.store = store;
-        this.executor = executor;
-        this.messagePollMs = messagePollMs;
     }
     async attach() {
-        if (this.sessionId)
+        if (this.session)
             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");
+        this.session = await frida.attach(this.process.pid);
         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);
+        this.script = await this.session.createScript(source);
+        this.script.message.connect(async (message) => {
             if (message.type !== "send")
-                continue;
-            const payload = asRecord(message.payload);
+                return;
+            const payload = message.payload;
             const parsed = ErrorEventSchema.safeParse({
                 ...payload,
                 pid: this.process.pid,
@@ -120,26 +30,13 @@ export class ProcessSession {
             });
             if (parsed.success)
                 await this.store.append(parsed.data);
-        }
-        this.messageCursor = messages.length;
+        });
+        await this.script.load();
     }
-    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
-        };
+    async detach() {
+        await this.script?.unload().catch(() => undefined);
+        await this.session?.detach().catch(() => undefined);
+        this.script = undefined;
+        this.session = undefined;
     }
 }
-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;
-}