frida-test 0.1.1 → 0.1.3

package/README.md

@@ -116,10 +116,10 @@ frida-test -i org.owasp.mastestapp.MASTestApp-iOS ./tests/ios ./tests/shared
 
 `frida-test` automatically bundles the test suites, and compiles them together with the testing framework into a Frida agent.
 
-If you only want to compile this agent, use `frida-test-compiler`:
+If you only want to compile this agent, use `frida-test-compile`:
 
 ```sh
-frida-test-compiler [options] <dir...>
+frida-test-compile [options] <dir...>
 ```
 
 | Option | Description |
@@ -127,12 +127,12 @@ frida-test-compiler [options] <dir...>
 | `-o, --out <path>` | Path of the output file for JSON reporter (default: disabled) |
 | `-h, --help` | Shows the help message |
 
-### `frida-test-compiler` Examples
+### `frida-test-compile` Examples
 
 ```sh
 # Collects all tests in ./tests, compiles the frida-test agent, and print it to stdout
-frida-test-compiler ./tests
+frida-test-compile ./tests
 
 # Collects all tests in ./tests, compile the frida-test agent, and stores it in the path ./frida-test-agent.js
-frida-test-compiler ./tests -o ./frida-test-agent.js
+frida-test-compile ./tests -o ./frida-test-agent.js
 ```

package/dist/bundler.js

@@ -1,15 +1,15 @@
-import { execFile } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
-import { copyFile, mkdir, mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
 import { logger } from "./logger.js";
 const IMPORT_MARKER = "/// IMPORT TESTS SUITES ///";
-const execFileAsync = promisify(execFile);
 const AGENT_ENTRYPOINT_FILENAME = "agentRuntime.ts";
-const AGENT_ENTRYPOINT_BASENAME = path.basename(AGENT_ENTRYPOINT_FILENAME, path.extname(AGENT_ENTRYPOINT_FILENAME));
+const AGENT_ENTRYPOINT_BASENAME = path.parse(AGENT_ENTRYPOINT_FILENAME).name;
 const AGENT_BUNDLE_FILENAME = `${AGENT_ENTRYPOINT_BASENAME}.bundle.js`;
-function resolveProjectRoot(startDir = process.cwd()) {
+function getProjectRoot() {
+    const startDir = process.cwd();
     let dir = startDir;
     while (true) {
         if (existsSync(path.join(dir, "package.json")))
@@ -20,45 +20,40 @@ function resolveProjectRoot(startDir = process.cwd()) {
         dir = parent;
     }
 }
-function resolveAgentRuntimePath(projectRoot) {
-    return path.join(projectRoot, "src", "agent-runtime");
-}
-function resolveFridaCompileBin(projectRoot) {
-    const binName = process.platform === "win32" ? "frida-compile.cmd" : "frida-compile";
-    return path.join(projectRoot, "node_modules", ".bin", binName);
-}
-let cachedProjectRoot;
-let cachedAgentRuntimeSrcDir;
-let cachedFridaCompileBin;
-function getProjectRoot() {
-    cachedProjectRoot ??= resolveProjectRoot();
-    return cachedProjectRoot;
-}
-function getAgentRuntimeSrcDir(projectRoot) {
-    if (!cachedAgentRuntimeSrcDir) {
-        const dir = resolveAgentRuntimePath(projectRoot);
-        if (!existsSync(dir)) {
-            throw new Error(`Agent runtime source directory not found at "${dir}".`);
+function getPackageRoot() {
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    while (true) {
+        if (existsSync(path.join(dir, "package.json")))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            throw new Error("Could not locate frida-test's own package.json.");
         }
-        cachedAgentRuntimeSrcDir = dir;
+        dir = parent;
     }
-    return cachedAgentRuntimeSrcDir;
 }
-function getFridaCompileBin(projectRoot) {
-    if (!cachedFridaCompileBin) {
-        const localBin = resolveFridaCompileBin(projectRoot);
-        cachedFridaCompileBin = existsSync(localBin) ? { path: localBin, useLocal: true } : { path: "npx", useLocal: false };
+function getAgentRuntimeSrcDir() {
+    const dir = path.join(getPackageRoot(), "src", "agent-runtime");
+    if (!existsSync(dir)) {
+        throw new Error(`Agent runtime source directory not found at "${dir}".`);
     }
-    return cachedFridaCompileBin;
+    return dir;
+}
+function getFridaCompileBin(projectRoot) {
+    const binName = process.platform === "win32" ? "frida-compile.cmd" : "frida-compile";
+    const localBin = path.join(projectRoot, "node_modules", ".bin", binName);
+    return existsSync(localBin) ? { path: localBin, useLocal: true } : { path: "npx", useLocal: false };
 }
 async function createWorkDir(projectRoot) {
-    const cacheRoot = path.join(projectRoot, ".frida-test-cache");
-    await mkdir(cacheRoot, { recursive: true });
-    const gitignorePath = path.join(cacheRoot, ".gitignore");
+    const workdirRoot = path.join(projectRoot, ".frida-test-cache");
+    await mkdir(workdirRoot, { recursive: true });
+    const gitignorePath = path.join(workdirRoot, ".gitignore");
     if (!existsSync(gitignorePath)) {
         await writeFile(gitignorePath, "*\n", "utf8");
     }
-    return mkdtemp(cacheRoot + path.sep);
+    const workdir = await mkdtemp(workdirRoot + path.sep);
+    logger.info(`Temporary workdir created at ${workdir}`);
+    return workdir;
 }
 async function deleteWorkDir(workDir) {
     try {
@@ -68,19 +63,6 @@ async function deleteWorkDir(workDir) {
         logger.warn(`Failed to remove temporary work dir "${workDir}": ${err.message}`);
     }
 }
-async function copyDirRecursive(srcDir, destDir) {
-    await mkdir(destDir, { recursive: true });
-    const entries = await readdir(srcDir, { withFileTypes: true });
-    await Promise.all(entries.map(async (entry) => {
-        const srcPath = path.join(srcDir, entry.name);
-        const destPath = path.join(destDir, entry.name);
-        if (entry.isDirectory()) {
-            await copyDirRecursive(srcPath, destPath);
-            return;
-        }
-        await copyFile(srcPath, destPath);
-    }));
-}
 export async function bundleAgent(testSuitePaths, keep = false) {
     if (testSuitePaths.length === 0) {
         throw new Error("bundleAgent requires at least one test suite path.");
@@ -88,8 +70,9 @@ export async function bundleAgent(testSuitePaths, keep = false) {
     const projectRoot = getProjectRoot();
     const workDir = await createWorkDir(projectRoot);
     try {
-        const agentRuntimeSrcDir = getAgentRuntimeSrcDir(projectRoot);
-        await copyDirRecursive(agentRuntimeSrcDir, workDir);
+        const agentRuntimeSrcDir = getAgentRuntimeSrcDir();
+        logger.info(`Agent runtime found in ${agentRuntimeSrcDir}`);
+        await cp(agentRuntimeSrcDir, workDir, { recursive: true });
         const entrypointPath = path.join(workDir, AGENT_ENTRYPOINT_FILENAME);
         const agentSource = await readFile(entrypointPath, "utf8");
         if (!agentSource.includes(IMPORT_MARKER)) {
@@ -106,26 +89,24 @@ export async function bundleAgent(testSuitePaths, keep = false) {
         await writeFile(entrypointPath, agentSource.replace(IMPORT_MARKER, importStatements), "utf8");
         const outfilePath = path.join(workDir, AGENT_BUNDLE_FILENAME);
         const fridaCompile = getFridaCompileBin(projectRoot);
-        let stdout;
-        let stderr;
+        const args = fridaCompile.useLocal ? [entrypointPath, "-o", outfilePath] : ["frida-compile", entrypointPath, "-o", outfilePath];
         try {
-            const args = fridaCompile.useLocal ? [entrypointPath, "-o", outfilePath] : ["frida-compile", entrypointPath, "-o", outfilePath];
-            ({ stdout, stderr } = await execFileAsync(fridaCompile.path, args, {
+            execFileSync(fridaCompile.path, args, {
                 cwd: projectRoot,
                 shell: process.platform === "win32",
-            }));
+                encoding: "utf8",
+            });
         }
         catch (err) {
-            throw new Error(`frida-compile failed for entrypoint "${entrypointPath}" with suites [${testSuitePaths.join(", ")}]: ${err.message}`, { cause: err });
+            const stderr = err.stderr?.toString().trim();
+            throw new Error(`frida-compile failed for entrypoint "${entrypointPath}" with suites [${testSuitePaths.join(", ")}]: ${stderr || err.message}`, { cause: err });
         }
-        if (stdout.trim())
-            logger.log(`[frida-compile] ${stdout.trim()}`);
-        if (stderr.trim())
-            logger.warn(`[frida-compile] ${stderr.trim()}`);
+        logger.info(`Agent bundle sucessfully created and saved at ${outfilePath}.`);
         return await readFile(outfilePath, "utf8");
     }
     finally {
         if (!keep) {
+            logger.info(`Cleaning up workdir.`);
             await deleteWorkDir(workDir);
         }
     }

package/dist/cli-frida-test-compiler.js

@@ -1,3 +1,9 @@
+import chalk from "chalk";
+import { writeFile } from "node:fs/promises";
+import { parseArgs } from "node:util";
+import { bundleAgent } from "./bundler.js";
+import { collectTestSuitePaths } from "./collector.js";
+import { logger } from "./logger.js";
 const usage = `
   Usage: frida-test-compiler [options] <src_path>...
 
@@ -5,34 +11,43 @@ const usage = `
     -o, --out <path>                Path of the output file for JSON reporter (default: disabled)
     -h, --help                      Show this help message
 `;
-import { writeFile } from "node:fs/promises";
-import { bundleAgent } from "./bundler.js";
-import { collectTestSuitePaths } from "./collector.js";
-const args = process.argv.slice(2);
-let outPath;
-const srcPaths = [];
-for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === "-o" || arg === "--out") {
-        outPath = args[++i];
-    }
-    else if (arg === "-h" || arg === "--help") {
+class CliError extends Error {
+}
+function fail(message) {
+    throw new CliError(message);
+}
+async function main() {
+    const { values, positionals } = parseArgs({
+        allowPositionals: true,
+        options: {
+            out: { type: "string", short: "o" },
+            help: { type: "boolean", short: "h", default: false },
+        },
+    });
+    if (values.help) {
         console.log(usage);
-        process.exit(0);
+        return;
+    }
+    if (positionals.length === 0) {
+        fail("Missing required argument <src_path>...");
+    }
+    const testSuitePaths = await collectTestSuitePaths(positionals);
+    const bundle = await bundleAgent(testSuitePaths);
+    if (values.out) {
+        await writeFile(values.out, bundle, "utf8");
     }
     else {
-        srcPaths.push(arg);
+        console.log(bundle);
     }
 }
-if (srcPaths.length === 0) {
-    console.error(usage);
-    process.exit(1);
-}
-const testSuitePaths = await collectTestSuitePaths(srcPaths);
-const bundle = await bundleAgent(testSuitePaths);
-if (outPath) {
-    await writeFile(outPath, bundle, "utf8");
-}
-else {
-    console.log(bundle);
-}
+main().catch((error) => {
+    if (error instanceof CliError) {
+        logger.error(error.message);
+        console.log(chalk.dim(usage));
+    }
+    else {
+        const msg = error instanceof Error ? error.message : String(error);
+        logger.error(`Fatal error: ${msg}`);
+    }
+    process.exitCode = 1;
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "frida-test",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "license": "GPL-3.0-only",
   "homepage": "https://github.com/bernhste/frida-test/blob/main/README.md",
@@ -20,14 +20,15 @@
   },
   "bin": {
     "frida-test": "bin/frida-test.js",
-    "frida-test-compiler": "bin/frida-test-compiler.js"
+    "frida-test-compile": "bin/frida-test-compile.js"
   },
   "types": "./src/agent-runtime/globals.d.ts",
   "exports": {
     ".": {
       "types": "./src/agent-runtime/globals.d.ts",
       "default": "./src/agent-runtime/globals.ts"
-    }
+    },
+    "./protocol.js": "./src/protocol.js"
   },
   "files": [
     "dist/",
@@ -35,10 +36,11 @@
     "src/agent-runtime"
   ],
   "scripts": {
-    "build": "npx tsc -b  &&  npm link",
-    "test:android": "npm run build && frida-test -U  -i 'com.google.android.dialer' ./tests/",
-    "watch": "npx tsc -b --watch",
-    "clean": "npx tsc -b --clean && npx rimraf dist"
+    "build": "tsc -b",
+    "watch": "tsc -b --watch",
+    "clean": "tsc -b --clean && rimraf dist",
+    "test:android": "npm run build && frida-test -U -i 'com.google.android.dialer' ./tests/",
+    "prepublishOnly": "npm run clean && npm run build && npm run test:android"
   },
   "allowScripts": {
     "frida": true

package/src/agent-runtime/agentRuntime.ts

@@ -1,5 +1,6 @@
 // AUTO-GENERATED by frida-test - do not edit
-import type { AgentMessage, RunSummary } from "../../src/protocol.js";
+/// <reference types="frida-gum" />
+import type { AgentMessage, RunSummary } from "frida-test/protocol.js";
 import "./globals.js";
 import "./matchers.js";
 import { registry, runTests } from "./registry.js";

package/src/agent-runtime/registry.ts

@@ -1,4 +1,3 @@
-// agent/registry.ts
 import { type AgentMessage, type RunSummary, type TestError, type TestResult, type TestStatus, type TestSuiteResult } from "../../src/protocol.js";
 
 export type TestFn = () => void | Promise<void>;