@testrigor/testrigor-cli 0.0.42-beta → 0.0.44-beta

package/README.md

@@ -31,3 +31,43 @@ This is a command line tool for TestRigor. It allows you to run TestRigor tests
 20. Show current configuration: `testrigor test-suite config --show`
 21. Authenticate with TestRigor and store credentials (interactive prompt): `testrigor authenticate`
 22. Run with override chrome extensions at runtime (one or more chrome extensions): `test-suite run <test-suite-id> --token <token> --chrome-extension "name=<extension-name> file=<extension-file>" --chrome-extension "name=<extension-name> file=<extension-file>"`
+
+### Mobile Testing
+
+Run mobile tests on your own local devices (emulators/simulators/real devices) using the same `--localhost` flag. The CLI auto-detects mobile suites and handles everything behind the scenes (mobile server, tunnel, configuration).
+
+#### Setup
+
+Run your test suite with `--localhost` and `--local-test-nodes-path`:
+
+```
+testrigor test-suite run <test-suite-id> --token <token> --localhost --local-test-nodes-path ./test-nodes.yaml
+```
+
+The CLI will:
+- Detect it's a mobile suite
+- Start the mobile server (Appium) automatically
+- Open a tunnel to TestRigor cloud
+- Run the test on your local device
+- Stop everything when done
+
+#### Override device config with a YAML file
+
+Instead of configuring devices in the UI, you can provide a local YAML file with `--local-test-nodes-path`:
+
+```
+testrigor test-suite run <test-suite-id> --token <token> --local-test-nodes-path ./test-nodes.yaml
+```
+
+Example `test-nodes.yaml`:
+
+```yaml
+testNodes:
+  - os: iOS
+    osVersion: "18.4"
+    abi: x86_64
+    x86_64: "iPhone 16 Pro"
+overrideTestNodes: true
+```
+
+This overrides the device config stored in the test suite and forces mobile mode (no need for `--localhost`).

package/dist/commands/test-suite/run.d.ts

@@ -17,6 +17,7 @@ export default class Run extends CommandBase<typeof Run> {
         "test-cases-path": import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
         "rules-path": import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
         "settings-path": import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        "local-test-nodes-path": import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
         "test-case-uuid": import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
         "auto-create-ai-rules": import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         "explicit-mutations": import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
@@ -28,6 +29,7 @@ export default class Run extends CommandBase<typeof Run> {
             name: string;
             file: string;
         } | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        "xray-execution-key": import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
     };
     static args: {
         testSuiteId: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
@@ -37,6 +39,8 @@ export default class Run extends CommandBase<typeof Run> {
     private fetchStatus;
     private getStatusApiEndpoint;
     private callRetest;
+    private fetchSuiteType;
+    private isMobileSuiteType;
     private uploadFile;
     private waitForTestSuiteToBeCreated;
     private waitForTestSuiteToFinish;

package/dist/commands/test-suite/run.js

@@ -11,6 +11,7 @@ const chrome_extension_1 = require("../../flags/chrome-extension");
 const parser_1 = require("../../util/parser");
 const request_builder_1 = require("../../util/request-builder");
 const tunnel_1 = require("../../util/tunnel");
+const appium_1 = require("../../util/appium");
 const utils_1 = require("../../util/utils");
 const sleep = async (milliseconds) => {
     await new Promise((resolve) => setTimeout(resolve, milliseconds));
@@ -70,6 +71,7 @@ class Run extends command_base_1.CommandBase {
         const maxPort = flags["max-port"];
         const url = flags["url"];
         const filePath = flags["file-path"];
+        const localTestNodesPath = flags["local-test-nodes-path"];
         const variablesPath = flags["variables-path"];
         const testCasesPath = flags["test-cases-path"];
         const rulesPath = flags["rules-path"];
@@ -79,6 +81,7 @@ class Run extends command_base_1.CommandBase {
         const explicitMutations = flags["explicit-mutations"];
         const labels = flags["labels"];
         const excludedLabels = flags["excluded-labels"];
+        const xrayExecutionKey = flags["xray-execution-key"];
         const chromeExtensions = flags["chrome-extension"];
         const context = {
             configuration: {
@@ -87,6 +90,8 @@ class Run extends command_base_1.CommandBase {
                 settings: {},
             },
             tunnel: new tunnel_1.default(),
+            isMobile: false,
+            appiumStartedByUs: false,
         };
         if (labels) {
             context.configuration.labels = labels;
@@ -94,6 +99,9 @@ class Run extends command_base_1.CommandBase {
         if (excludedLabels) {
             context.configuration.excludedLabels = excludedLabels;
         }
+        if (xrayExecutionKey) {
+            context.configuration.xrayExecutionKey = xrayExecutionKey;
+        }
         if (minPort > maxPort) {
             core_1.ux.error("--minPort cannot be greater than --maxPort");
         }
@@ -149,6 +157,24 @@ class Run extends command_base_1.CommandBase {
                 core_1.ux.error("--settings-path must be a valid JSON/YAML path");
             }
         }
+        if (localTestNodesPath) {
+            try {
+                const localTestNodes = await (0, parser_1.parseSettings)(localTestNodesPath);
+                if (localTestNodes) {
+                    if (Array.isArray(localTestNodes.testNodes)) {
+                        for (const node of localTestNodes.testNodes) {
+                            if (!node.provider) {
+                                node.provider = "LOCALHOST";
+                            }
+                        }
+                    }
+                    Object.assign(context.configuration, localTestNodes);
+                }
+            }
+            catch (e) {
+                core_1.ux.error("--local-test-nodes-path must be a valid JSON/YAML path");
+            }
+        }
         if (filePath) {
             if (url) {
                 core_1.ux.info("WARNING: File path will be ignored because --url is used");
@@ -168,50 +194,85 @@ class Run extends command_base_1.CommandBase {
             context.chromeExtensions = chromeExtensions;
         }
         super.setTunnel(context.tunnel);
+        if (localTestNodesPath) {
+            context.isMobile = true;
+        }
+        else if (flags.localhost) {
+            const suiteType = await this.fetchSuiteType(testSuiteId, token);
+            context.isMobile = this.isMobileSuiteType(suiteType);
+        }
         const tasks = [
             {
-                enabled: () => flags.localhost,
+                enabled: () => (flags.localhost || !!localTestNodesPath) && context.isMobile,
                 task: (ctx, task) => {
-                    if (flags.verbose) {
-                        task.title = "Initializing tunnel";
-                    }
-                    else {
-                        task.title = "Initializing";
-                    }
+                    task.title = "Starting mobile server";
                     return task.newListr([
                         {
-                            task: async (ctx, task) => {
-                                if (flags.verbose) {
-                                    task.title = "Downloading binary";
+                            task: async (_ctx, subtask) => {
+                                await (0, appium_1.checkAppiumInstalled)();
+                                subtask.title = "Mobile server binary found";
+                            },
+                            rendererOptions: { timer: listr2_1.PRESET_TIMER },
+                        },
+                        ...appium_1.REQUIRED_DRIVERS.map((driver) => ({
+                            task: async (_ctx, subtask) => {
+                                const status = await (0, appium_1.getDriverStatus)(driver.name, driver.version);
+                                if (status.installed && status.upToDate) {
+                                    subtask.title = `Driver ${driver.name}@${driver.version} ready`;
+                                    return;
                                 }
-                                await ctx.tunnel.initialize();
+                                subtask.title = status.installed
+                                    ? `Updating ${driver.name} (${status.version} → ${driver.version})`
+                                    : `Installing ${driver.name}@${driver.version}`;
+                                const err = await (0, appium_1.ensureDriver)(driver.name, driver.version);
+                                subtask.title = err
+                                    ? `Driver ${driver.name} skipped — ${err}`
+                                    : `Driver ${driver.name}@${driver.version} ready`;
+                            },
+                            rendererOptions: { timer: listr2_1.PRESET_TIMER },
+                        })),
+                        {
+                            task: async (ctx, subtask) => {
+                                const result = await (0, appium_1.startAppium)();
+                                ctx.appiumStartedByUs = !result.alreadyRunning;
+                                subtask.title = result.alreadyRunning
+                                    ? `Mobile server already running (PID: ${result.pid}), reusing`
+                                    : `Mobile server started (PID: ${result.pid})`;
                             },
-                            rendererOptions: {
-                                timer: listr2_1.PRESET_TIMER,
+                            rendererOptions: { timer: listr2_1.PRESET_TIMER },
+                        },
+                    ], { concurrent: false, rendererOptions: { collapseSubtasks: false } });
+                },
+            },
+            {
+                enabled: () => flags.localhost || !!localTestNodesPath,
+                task: (ctx, task) => {
+                    task.title = flags.verbose ? "Initializing tunnel" : "Initializing";
+                    return task.newListr([
+                        {
+                            task: async (ctx, subtask) => {
+                                await ctx.tunnel.initialize();
+                                subtask.title = "Binary ready";
                             },
+                            rendererOptions: { timer: listr2_1.PRESET_TIMER },
                         },
                         {
-                            task: async (ctx, task) => {
-                                if (flags.verbose) {
-                                    task.title = "Starting tunnel";
-                                }
+                            task: async (ctx, subtask) => {
                                 await ctx.tunnel.start(minPort, maxPort);
+                                subtask.title = `Tunnel started (port ${ctx.tunnel.getPort()})`;
                             },
                             exitOnError: true,
-                            rendererOptions: {
-                                timer: listr2_1.PRESET_TIMER,
-                            },
+                            rendererOptions: { timer: listr2_1.PRESET_TIMER },
                         },
                         {
                             enabled: (ctx) => ctx.tunnel.isRunning(),
-                            task: (ctx, task) => {
-                                if (flags.verbose) {
-                                    task.title = `Tunnel started at port ${ctx.tunnel.getPort()}`;
-                                }
+                            task: (ctx, subtask) => {
+                                const tunnelAddress = `tunnel.testrigor.com:${ctx.tunnel.getPort()}`;
                                 ctx.configuration.settings = {
                                     ...ctx.configuration.settings,
-                                    httpProxyString: `tunnel.testrigor.com:${ctx.tunnel.getPort()}`,
+                                    httpProxyString: tunnelAddress,
                                 };
+                                subtask.title = `Tunnel connected (${tunnelAddress})`;
                             },
                         },
                     ], { concurrent: false, rendererOptions: { collapseSubtasks: false } });
@@ -223,7 +284,11 @@ class Run extends command_base_1.CommandBase {
                     {
                         // Checking last run id
                         task: async (ctx) => {
-                            const statusResponse = await this.fetchStatus(testSuiteId, token, flags.branch, ctx.configuration.labels, ctx.configuration.excludedLabels);
+                            let pollBranch = flags.branch;
+                            if (testCaseUuid && !flags.branch) {
+                                pollBranch = `single-test-execution-${testCaseUuid}`;
+                            }
+                            const statusResponse = await this.fetchStatus(testSuiteId, token, pollBranch, ctx.configuration.labels, ctx.configuration.excludedLabels);
                             context.lastRunId = (0, utils_1.extractRunIdFromDetailsUrl)(statusResponse.detailsUrl);
                         },
                         exitOnError: false,
@@ -385,7 +450,11 @@ class Run extends command_base_1.CommandBase {
                         title: "Waiting for test suite run creation",
                         enabled: (ctx) => ctx.response?.queueId,
                         task: async (ctx, currentTask) => {
-                            const detailsUrl = await this.waitForTestSuiteToBeCreated(testSuiteId, token, ctx.lastRunId, flags.branch, ctx.configuration.labels, ctx.configuration.excludedLabels);
+                            let pollBranch = flags.branch;
+                            if (testCaseUuid && !flags.branch) {
+                                pollBranch = `single-test-execution-${testCaseUuid}`;
+                            }
+                            const detailsUrl = await this.waitForTestSuiteToBeCreated(testSuiteId, token, ctx.lastRunId, pollBranch, ctx.configuration.labels, ctx.configuration.excludedLabels);
                             task.title = `Running test suite [ ${detailsUrl} ]`;
                             currentTask.title = "Test suite run created successfully";
                         },
@@ -394,13 +463,19 @@ class Run extends command_base_1.CommandBase {
                     {
                         title: "Checking status",
                         enabled: (ctx) => ctx.response?.result === "ok" && !flags.async,
-                        task: async (ctx, task) => task.newListr([
-                            {
-                                task: async (ctx, statusTask) => {
-                                    await this.waitForTestSuiteToFinish(testSuiteId, token, statusTask, flags.branch, ctx.configuration.labels, ctx.configuration.excludedLabels);
+                        task: async (ctx, task) => {
+                            let pollBranch = flags.branch;
+                            if (testCaseUuid && !flags.branch) {
+                                pollBranch = `single-test-execution-${testCaseUuid}`;
+                            }
+                            return task.newListr([
+                                {
+                                    task: async (ctx, statusTask) => {
+                                        await this.waitForTestSuiteToFinish(testSuiteId, token, statusTask, pollBranch, ctx.configuration.labels, ctx.configuration.excludedLabels);
+                                    },
                                 },
-                            },
-                        ]),
+                            ]);
+                        },
                         exitOnError: false,
                     },
                     {
@@ -438,6 +513,15 @@ class Run extends command_base_1.CommandBase {
                     await ctx.tunnel.stop();
                 },
             },
+            {
+                enabled: (ctx) => ctx.appiumStartedByUs,
+                task: async (_ctx, task) => {
+                    if (flags.verbose) {
+                        task.title = "Stopping mobile server";
+                    }
+                    await (0, appium_1.stopAppium)();
+                },
+            },
         ];
         const runner = new listr2_1.Listr(tasks, {
             ctx: context,
@@ -491,6 +575,24 @@ class Run extends command_base_1.CommandBase {
             },
         });
     }
+    async fetchSuiteType(testSuiteId, token) {
+        const response = await (0, node_fetch_commonjs_1.default)(`${this.TESTRIGOR_API_URL}/apps/${testSuiteId}/status`, {
+            method: "GET",
+            headers: {
+                Accept: "application/json",
+                "auth-token": token,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch test suite info: ${response.statusText}`);
+        }
+        const data = (await response.json());
+        return data.type || "";
+    }
+    isMobileSuiteType(type) {
+        const mobilePrefixes = ["IOS_", "ANDROID_"];
+        return mobilePrefixes.some((prefix) => type.toUpperCase().startsWith(prefix));
+    }
     async uploadFile(task, testSuiteId, configuration, filePath, token, fileProperties) {
         const body = {
             fileName: fileProperties.fileName,
@@ -664,9 +766,8 @@ Run.flags = {
         dependsOn: ["branch"],
     }),
     localhost: core_1.Flags.boolean({
-        description: "Localhost run",
+        description: "Localhost run (auto-detects web vs mobile)",
         aliases: ["tunnel"],
-        dependsOn: ["url"],
     }),
     url: core_1.Flags.string({
         description: "The url",
@@ -689,9 +790,11 @@ Run.flags = {
     "settings-path": core_1.Flags.string({
         description: "Settings path",
     }),
+    "local-test-nodes-path": core_1.Flags.string({
+        description: "Path to a YAML or JSON file with local test nodes configuration",
+    }),
     "test-case-uuid": core_1.Flags.string({
         description: "Test case uuid",
-        dependsOn: ["url"],
     }),
     "auto-create-ai-rules": core_1.Flags.boolean({
         description: "Enable auto create AI based rules",
@@ -718,6 +821,9 @@ Run.flags = {
     "chrome-extension": (0, chrome_extension_1.ChromeExtensionFlag)({
         exclusive: ["file-path"],
     }),
+    "xray-execution-key": core_1.Flags.string({
+        description: "Reuse an existing Xray Cloud Test Execution by key (e.g. XR-123) instead of creating a new one. Optional; leave blank to create a new execution.",
+    }),
 };
 Run.args = {
     testSuiteId: core_1.Args.string({

package/dist/util/appium.d.ts

@@ -0,0 +1,25 @@
+declare const DEFAULT_PORT = 4723;
+declare const DEFAULT_BASE_PATH = "/wd/hub";
+declare const PID_DIR: string;
+declare const PID_FILE: string;
+declare const REQUIRED_DRIVERS: Array<{
+    name: string;
+    version: string;
+}>;
+export { DEFAULT_PORT, DEFAULT_BASE_PATH, REQUIRED_DRIVERS, PID_DIR, PID_FILE };
+export declare function checkAppiumInstalled(): Promise<void>;
+export type DriverStatus = {
+    installed: boolean;
+    version?: string;
+    upToDate: boolean;
+};
+export declare function getDriverStatus(driverName: string, requiredVersion: string): Promise<DriverStatus>;
+export declare function ensureDriver(driverName: string, requiredVersion: string): Promise<string | null>;
+export declare function isProcessRunning(pid: number): boolean;
+export type StartResult = {
+    pid: number;
+    alreadyRunning: boolean;
+};
+export declare function getRunningAppiumPid(): Promise<number | null>;
+export declare function startAppium(port?: number, logLevel?: string): Promise<StartResult>;
+export declare function stopAppium(): Promise<number | null>;

package/dist/util/appium.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopAppium = exports.startAppium = exports.getRunningAppiumPid = exports.isProcessRunning = exports.ensureDriver = exports.getDriverStatus = exports.checkAppiumInstalled = exports.PID_FILE = exports.PID_DIR = exports.REQUIRED_DRIVERS = exports.DEFAULT_BASE_PATH = exports.DEFAULT_PORT = void 0;
+const childProcess = require("child_process");
+const fs = require("fs");
+const util = require("util");
+const path = require("path");
+const os = require("os");
+const Fs = require("@supercharge/fs");
+const execFile = util.promisify(childProcess.execFile);
+const PROJECT_ROOT = path.resolve(__dirname, "..", "..");
+const APPIUM_HOME = path.join(PROJECT_ROOT, ".appium");
+const DEFAULT_PORT = 4723;
+exports.DEFAULT_PORT = DEFAULT_PORT;
+const DEFAULT_BASE_PATH = "/wd/hub";
+exports.DEFAULT_BASE_PATH = DEFAULT_BASE_PATH;
+const PID_DIR = path.join(os.homedir(), ".testrigor");
+exports.PID_DIR = PID_DIR;
+const PID_FILE = path.join(PID_DIR, "appium.pid");
+exports.PID_FILE = PID_FILE;
+const LOG_FILE = path.join(os.tmpdir(), "testrigor-appium.log");
+const REQUIRED_DRIVERS = [
+    { name: "uiautomator2", version: "4.2.3" },
+    { name: "xcuitest", version: "9.2.4" },
+];
+exports.REQUIRED_DRIVERS = REQUIRED_DRIVERS;
+function getAppiumBin() {
+    return path.resolve(PROJECT_ROOT, "node_modules", ".bin", "appium");
+}
+function getAppiumEnv() {
+    return {
+        ...process.env,
+        APPIUM_HOME,
+        CHROMELABS_URL: "https://googlechromelabs.github.io",
+    };
+}
+async function checkAppiumInstalled() {
+    const appiumBin = getAppiumBin();
+    if (!(await Fs.exists(appiumBin))) {
+        throw new Error(`Appium binary not found at ${appiumBin}. Try reinstalling testrigor-cli.`);
+    }
+    try {
+        await execFile(appiumBin, ["--version"], { env: getAppiumEnv() });
+    }
+    catch {
+        throw new Error(`Appium binary at ${appiumBin} is not working. Try reinstalling testrigor-cli.`);
+    }
+}
+exports.checkAppiumInstalled = checkAppiumInstalled;
+async function getDriverStatus(driverName, requiredVersion) {
+    const appiumBin = getAppiumBin();
+    try {
+        const { stdout } = await execFile(appiumBin, ["driver", "list", "--installed", "--json"], { encoding: "utf8", env: getAppiumEnv() });
+        const drivers = JSON.parse(stdout);
+        const info = drivers[driverName];
+        if (!info || !info.installed) {
+            return { installed: false, upToDate: false };
+        }
+        return {
+            installed: true,
+            version: info.version,
+            upToDate: info.version === requiredVersion,
+        };
+    }
+    catch {
+        return { installed: false, upToDate: false };
+    }
+}
+exports.getDriverStatus = getDriverStatus;
+async function ensureDriver(driverName, requiredVersion) {
+    const appiumBin = getAppiumBin();
+    const env = getAppiumEnv();
+    const status = await getDriverStatus(driverName, requiredVersion);
+    if (status.installed && status.upToDate) {
+        return null;
+    }
+    try {
+        if (status.installed) {
+            await execFile(appiumBin, ["driver", "uninstall", driverName], {
+                encoding: "utf8",
+                env,
+            });
+        }
+        await execFile(appiumBin, ["driver", "install", `${driverName}@${requiredVersion}`], { encoding: "utf8", env });
+        return null;
+    }
+    catch (error) {
+        const raw = error instanceof Error ? error.message : String(error);
+        return raw.split("\n")[0].replace(/^Command failed:.*?Error:\s*/, "").trim();
+    }
+}
+exports.ensureDriver = ensureDriver;
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+exports.isProcessRunning = isProcessRunning;
+function killSafe(pid) {
+    if (isProcessRunning(pid)) {
+        process.kill(pid);
+    }
+}
+async function getRunningAppiumPid() {
+    if (!(await Fs.exists(PID_FILE))) {
+        return null;
+    }
+    const existingPid = Number((await Fs.content(PID_FILE)).trim());
+    if (isProcessRunning(existingPid)) {
+        return existingPid;
+    }
+    await Fs.removeFile(PID_FILE);
+    return null;
+}
+exports.getRunningAppiumPid = getRunningAppiumPid;
+async function healthCheck(port, retries = 15, interval = 2000) {
+    const url = `http://127.0.0.1:${port}/wd/hub/status`;
+    let lastError = "";
+    for (let i = 0; i < retries; i++) {
+        try {
+            const res = await fetch(url);
+            const body = await res.json();
+            if (body.value?.ready)
+                return;
+            lastError = "server responded but not ready";
+        }
+        catch (err) {
+            lastError = err.message || String(err);
+        }
+        await new Promise((r) => setTimeout(r, interval));
+    }
+    throw new Error(`Mobile server not ready after ${retries} attempts: ${lastError}`);
+}
+async function startAppium(port = DEFAULT_PORT, logLevel = "debug") {
+    const existingPid = await getRunningAppiumPid();
+    if (existingPid) {
+        return { pid: existingPid, alreadyRunning: true };
+    }
+    const appiumBin = getAppiumBin();
+    const logStream = fs.openSync(LOG_FILE, "a");
+    const appiumProcess = childProcess.spawn(appiumBin, [
+        "--port",
+        String(port),
+        "--base-path",
+        DEFAULT_BASE_PATH,
+        "--allow-insecure",
+        "chromedriver_autodownload",
+        "--log-level",
+        logLevel,
+    ], {
+        detached: true,
+        stdio: ["ignore", logStream, logStream],
+        env: getAppiumEnv(),
+    });
+    const pid = appiumProcess.pid;
+    if (!pid) {
+        throw new Error("Failed to start Appium server: no PID returned");
+    }
+    appiumProcess.unref();
+    await Fs.ensureDir(PID_DIR);
+    await Fs.writeFile(PID_FILE, String(pid));
+    try {
+        await healthCheck(port);
+    }
+    catch (err) {
+        killSafe(pid);
+        await Fs.removeFile(PID_FILE);
+        throw err;
+    }
+    return { pid, alreadyRunning: false };
+}
+exports.startAppium = startAppium;
+async function stopAppium() {
+    if (!(await Fs.exists(PID_FILE))) {
+        return null;
+    }
+    const pidContent = (await Fs.content(PID_FILE)).trim();
+    const pid = Number(pidContent);
+    if (!isNaN(pid) && isProcessRunning(pid)) {
+        process.kill(pid, "SIGTERM");
+    }
+    await Fs.removeFile(PID_FILE);
+    return pid;
+}
+exports.stopAppium = stopAppium;

package/dist/util/trtc.d.ts

@@ -1 +1,2 @@
+export declare const BINARY_NAME: string;
 export declare function download(dir: string): Promise<string | null>;

package/dist/util/trtc.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.download = void 0;
+exports.download = exports.BINARY_NAME = void 0;
 const Fs = require("@supercharge/fs");
 const fs = require("fs");
 const node_fetch_commonjs_1 = require("node-fetch-commonjs");
@@ -25,6 +25,10 @@ const ARCHITECTURE_MAP = {
     arm64: "arm64",
 };
 const VERSION = "2.3.15";
+const WIN32_PLATFORM = "win32";
+const WIN32_BINARY = "trtc.exe";
+const UNIX_BINARY = "trtc";
+exports.BINARY_NAME = os.platform() === WIN32_PLATFORM ? WIN32_BINARY : UNIX_BINARY;
 function getFolderName() {
     const platform = os.platform();
     const architecture = os.arch();

package/dist/util/tunnel.d.ts

@@ -4,6 +4,7 @@ export default class Tunnel {
     private process;
     private port;
     private binaryPath?;
+    private configPath?;
     constructor();
     initialize(): Promise<void>;
     start(minPort: number, maxPort: number): Promise<void>;

package/dist/util/tunnel.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const Fs = require("@supercharge/fs");
 const childProcess = require("child_process");
-const os = require("os");
 const path = require("path");
 const trtc_1 = require("./trtc");
 const utils_1 = require("./utils");
@@ -11,24 +10,25 @@ function randomPort(min, max) {
 }
 async function updateConfig(dir, port) {
     const parentDir = path.dirname(dir);
-    const configPath = `${parentDir}/config.toml`;
+    const configPath = path.join(parentDir, "config.toml");
     const newConfigContent = `[[proxies]]
 name = "http_proxy_${port}"
 type = "tcp"
 remotePort = ${port}
 [proxies.plugin]
 type = "http_proxy"`;
-    return Fs.writeFile(configPath, newConfigContent);
+    await Fs.writeFile(configPath, newConfigContent);
+    return configPath;
 }
-async function startTrtc(trtc, command) {
+async function startTrtc(trtc, command, configPath) {
     return new Promise((resolve, reject) => {
         const binaryPath = path.join(path.dirname(trtc), command);
-        const workingDir = path.dirname(trtc); // This is where config.toml is written
+        const workingDir = path.dirname(trtc);
         if (!Fs.pathExistsSync(binaryPath)) {
             reject(new Error(`Binary not found at ${binaryPath}`));
             return;
         }
-        const tunnelProcess = childProcess.spawn(binaryPath, [], {
+        const tunnelProcess = childProcess.spawn(binaryPath, ["-c", configPath], {
             cwd: workingDir,
         });
         tunnelProcess.stdout.on("data", (data) => {
@@ -68,13 +68,13 @@ class Tunnel {
         if (this.binaryPath == null) {
             throw new Error("Could not download the trtc binary");
         }
-        const command = os.platform() === "win32" ? "trtc.exe" : "trtc";
+        const command = trtc_1.BINARY_NAME;
         let maxTries = 40;
         while (maxTries > 0) {
             try {
                 this.port = randomPort(minPort, maxPort);
-                await updateConfig(this.binaryPath, this.port);
-                this.process = await startTrtc(this.binaryPath, command);
+                this.configPath = await updateConfig(this.binaryPath, this.port);
+                this.process = await startTrtc(this.binaryPath, command, this.configPath);
                 break;
             }
             catch (e) {

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.42-beta",
+  "version": "0.0.44-beta",
   "commands": {
     "authenticate": {
       "id": "authenticate",
@@ -147,11 +147,8 @@
         "localhost": {
           "name": "localhost",
           "type": "boolean",
-          "description": "Localhost run",
+          "description": "Localhost run (auto-detects web vs mobile)",
           "allowNo": false,
-          "dependsOn": [
-            "url"
-          ],
           "aliases": [
             "tunnel"
           ]
@@ -198,14 +195,17 @@
           "description": "Settings path",
           "multiple": false
         },
+        "local-test-nodes-path": {
+          "name": "local-test-nodes-path",
+          "type": "option",
+          "description": "Path to a YAML or JSON file with local test nodes configuration",
+          "multiple": false
+        },
         "test-case-uuid": {
           "name": "test-case-uuid",
           "type": "option",
           "description": "Test case uuid",
-          "multiple": false,
-          "dependsOn": [
-            "url"
-          ]
+          "multiple": false
         },
         "auto-create-ai-rules": {
           "name": "auto-create-ai-rules",
@@ -251,6 +251,12 @@
           "exclusive": [
             "file-path"
           ]
+        },
+        "xray-execution-key": {
+          "name": "xray-execution-key",
+          "type": "option",
+          "description": "Reuse an existing Xray Cloud Test Execution by key (e.g. XR-123) instead of creating a new one. Optional; leave blank to create a new execution.",
+          "multiple": false
         }
       },
       "args": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testrigor/testrigor-cli",
-  "version": "0.0.42-beta",
+  "version": "0.0.44-beta",
   "description": "TestRigor Command Line",
   "author": "Ivo Parun Rua @parunruaivo",
   "bin": {
@@ -9,10 +9,14 @@
   "homepage": "https://github.com/TestRigor/testrigor-cli",
   "license": "MIT",
   "main": "dist/index.ts",
-  "repository": "TestRigor/testrigor-cli",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TestRigor/testrigor-cli.git"
+  },
   "files": [
     "/bin",
     "/dist",
+    "/.appium",
     "/npm-shrinkwrap.json",
     "oclif.manifest.json"
   ],
@@ -21,6 +25,7 @@
     "@oclif/plugin-help": "^5",
     "@oclif/plugin-plugins": "^3.2.0",
     "@supercharge/fs": "^3.4.0",
+    "appium": "^2.18",
     "form-data": "^4.0.1",
     "glob": "^10.3.10",
     "gunzip-maybe": "^1.4.2",
@@ -85,7 +90,7 @@
     "prepack": "npm run build && oclif manifest && oclif readme",
     "test": "mocha --forbid-only \"test/**/*.ts\"",
     "version": "oclif readme && git add README.md",
-    "tarballs": "npm run prepack && oclif pack tarballs"
+    "tarballs": "npm run prepack && oclif pack tarballs --targets linux-x64,linux-arm64,darwin-x64,darwin-arm64,win32-x64"
   },
   "engines": {
     "node": ">=18.0.0"