Add types & tests for log message listening

Author: pimterry

src/index.ts

@@ -92,22 +92,35 @@ type AgentMessage = [kind: number, script_id: number[], text: string, has_data:
  */
 export enum MessageType {
     Send = "send",
-    Error = "error"
+    Error = "error",
+    Log = "log"
 }
 
-export type Message = ScriptAgentSendMessage | ScriptAgentErrorMessage;
-export type ScriptAgentSendMessage = {
-    type: MessageType.Send,
-    payload: any
+export type Message =
+    | ScriptAgentSendMessage
+    | ScriptAgentErrorMessage
+    | ScriptAgentLogMessage;
+
+export interface ScriptAgentSendMessage {
+    type: MessageType.Send;
+    payload: any;
 }
-export type ScriptAgentErrorMessage = {
+
+export interface ScriptAgentErrorMessage {
     type: MessageType.Error;
     description: string;
     stack?: string;
     fileName?: string;
     lineNumber?: number;
     columnNumber?: number;
 }
+
+export interface ScriptAgentLogMessage {
+    type: MessageType.Log,
+    level: string,
+    payload: string
+}
+
 enum AgentMessageKind {
     Script = 1,
     Debugger = 2,

test/test.spec.ts

@@ -8,7 +8,11 @@ import { expect } from 'chai';
 import { fetch } from 'cross-fetch';
 
 import { delay, isNode } from './test-util';
-import { connect, FridaSession, Message, MessageType, ScriptAgentSendMessage } from '../src/index';
+import {
+    connect,
+    FridaSession,
+    Message
+} from '../src/index';
 
 const FIXTURES_BASE = isNode
     ? path.join(__dirname, 'fixtures')
@@ -33,7 +37,7 @@ describe("Frida-JS", () => {
             }
         }
         spawnedProc = undefined;
-    })
+    });
 
     it("can connect to Frida and list target processes", async () => {
         fridaClient = await connect();
@@ -113,6 +117,67 @@ describe("Frida-JS", () => {
         expect(resultingMessage).to.equal('INJECTED');
     });
 
+    it("can get a message explicitly sent from the script", async () => {
+        const expectedMessage = 'Hello from injected script!';
+
+        // Start a demo subprocess to inject into:
+        fridaClient = await connect();
+        const { session } = await fridaClient.spawnWithScript(
+            path.join(FIXTURES_BASE, `serve-${process.platform}-${process.arch}`),
+            [],
+            `
+                setTimeout(() => {
+                    send('${expectedMessage}');
+                }, 100);
+            `
+        );
+
+        let message = await new Promise<Message | null>((resolve, reject) => {
+            session.onMessage(resolve);
+            setTimeout(() => {
+                reject(new Error('Timed out waiting for message'));
+            }, 1000);
+        });
+
+        await fetch('http://127.0.0.1:3000'); // Fetch triggers shutdown
+
+        expect(message).to.deep.equal({
+            type: 'send',
+            payload: expectedMessage
+        });
+    });
+
+    it("can get a message console logged from a script", async () => {
+        const expectedMessage = 'Logged warning message!';
+
+        // Start a demo subprocess to inject into:
+        fridaClient = await connect();
+        const { session } = await fridaClient.spawnWithScript(
+            path.join(FIXTURES_BASE, `serve-${process.platform}-${process.arch}`),
+            [],
+            `
+                setTimeout(() => {
+                    console.warn('${expectedMessage}');
+                }, 100);
+            `
+        );
+
+        let message = await new Promise<Message | null>((resolve, reject) => {
+            session.onMessage(resolve);
+            setTimeout(() => {
+                reject(new Error('Timed out waiting for message'));
+            }, 1000);
+        });
+
+        await fetch('http://127.0.0.1:3000'); // Fetch triggers shutdown
+
+        expect(message).to.deep.equal({
+            type: 'log',
+            level: 'warning',
+            payload: expectedMessage
+        });
+    });
+
     it("can receive script errors from a launched process", async () => {
         // Launch a server process with a failing script injected
         fridaClient = await connect();
@@ -122,7 +187,7 @@ describe("Frida-JS", () => {
             // Run an example script that always crashes:
             "throw new Error('Intentional script failure error');"
         );
-        const messages: any[] = [];
+        const messages: Message[] = [];
         session.onMessage((msg) => messages.push(msg));
 
         await delay(100); // Wait momentarily for the server to start listening
@@ -255,57 +320,6 @@ describe("Frida-JS", () => {
             expect(output).to.equal('Hello from injected script!\n');
         });
 
-        it("can get the send message from agent", async () => {
-            // Start a demo subprocess to inject into:
-            const childProc = ChildProc.spawn(
-                // Fixture that loops until should_continue() returns false (which it never does).
-                // Source is in fixtures-setup/rust-loop.
-                path.join(__dirname, 'fixtures', `loop-${process.platform}-${process.arch}${process.platform === 'win32' ? '.exe' : ''}`),
-                { stdio: 'pipe' }
-            );
-            childProc.unref();
-            spawnedProc = childProc; // Ensure this is killed after testing
-
-            const outputPromise = new Promise<{
-                exitCode: number | null,
-                output: string
-            }>((resolve, reject) => {
-                let output = '';
-                childProc.stdout.on('data', (msg) => output += msg.toString());
-                childProc.stderr.on('data', (msg) => output += msg.toString());
-                childProc.stdout.pipe(process.stdout);
-                childProc.stderr.pipe(process.stderr);
-                childProc.on('close', (exitCode) => resolve({ exitCode, output }));
-                childProc.on('error', reject);
-            });
-
-            // Wait for the target to start up:
-            await new Promise((resolve, reject) => {
-                childProc.on('spawn', resolve);
-                childProc.on('error', reject);
-            });
-
-            // Inject into it:
-            const expectedMessage = 'Hello from injected script!';
-            fridaClient = await connect();
-            const data = await fridaClient.injectIntoProcess(childProc.pid!, `
-                setTimeout(() => {
-                    send('${expectedMessage}');
-                }, 1000);
-            `);
-
-            let message = await new Promise<Message | null>((resolve, reject) => {
-                data.session.onMessage(resolve);
-                setTimeout(() => {
-                    reject(new Error('Timed out waiting for message'));
-                }, 5000);
-            });
-
-            // Inject into it:
-            expect(message?.type).to.equal(MessageType.Send);
-            expect((message as ScriptAgentSendMessage)?.payload).to.equal(expectedMessage);
-        });
-
         it("can kill a target process", async () => {
             // Start a demo subprocess to kill:
             const childProc = ChildProc.spawn(