@testrigor/testrigor-cli 0.0.42-beta → 0.0.45-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>>;
@@ -36,7 +38,11 @@ export default class Run extends CommandBase<typeof Run> {
     run(): Promise<void>;
     private fetchStatus;
     private getStatusApiEndpoint;
+    private uploadVariableFiles;
+    private uploadClientCertificates;
     private callRetest;
+    private fetchSuiteType;
+    private isMobileSuiteType;
     private uploadFile;
     private waitForTestSuiteToBeCreated;
     private waitForTestSuiteToFinish;

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

@@ -11,6 +11,10 @@ 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 certificate_uploader_1 = require("../../util/certificate-uploader");
+const variable_file_uploader_1 = require("../../util/variable-file-uploader");
+const variables_path_parser_1 = require("../../util/variables-path-parser");
+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 +74,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 +84,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 +93,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 +102,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");
         }
@@ -110,10 +121,23 @@ class Run extends command_base_1.CommandBase {
         if (variablesPath) {
             try {
                 const file = await Fs.content(variablesPath);
-                context.configuration.storedValues = JSON.parse(file.toString());
+                const parsed = JSON.parse(file.toString());
+                const { textValues, fileInputs, certInputs } = (0, variables_path_parser_1.parseVariablesJson)(parsed);
+                context.configuration.storedValues = textValues;
+                if (fileInputs.length > 0) {
+                    context.storedValueFileInputs = fileInputs;
+                }
+                if (certInputs.length > 0) {
+                    context.storedValueCertInputs = certInputs;
+                }
             }
             catch (e) {
-                core_1.ux.error("--variables-path must be a valid JSON path");
+                if (e instanceof SyntaxError) {
+                    core_1.ux.error("--variables-path must be a valid JSON path");
+                }
+                else {
+                    core_1.ux.error(e instanceof Error ? e.message : String(e));
+                }
             }
         }
         if (testCasesPath) {
@@ -149,6 +173,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 +210,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,
+                            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 },
                         },
+                    ], { 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, task) => {
-                                if (flags.verbose) {
-                                    task.title = "Starting tunnel";
-                                }
+                            task: async (ctx, subtask) => {
+                                await ctx.tunnel.initialize();
+                                subtask.title = "Binary ready";
+                            },
+                            rendererOptions: { timer: listr2_1.PRESET_TIMER },
+                        },
+                        {
+                            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,11 +300,27 @@ 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,
                     },
+                    {
+                        title: "Uploading variable files",
+                        enabled: () => !!context.storedValueFileInputs?.length,
+                        task: (ctx) => this.uploadVariableFiles(ctx, testSuiteId, token),
+                        exitOnError: false,
+                    },
+                    {
+                        title: "Uploading client certificates",
+                        enabled: () => !!context.storedValueCertInputs?.length,
+                        task: (ctx, task) => this.uploadClientCertificates(ctx, testSuiteId, token, task),
+                        exitOnError: false,
+                    },
                     {
                         enabled: () => !flags["file-path"] && !flags["chrome-extension"],
                         task: async (ctx) => {
@@ -385,7 +478,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 +491,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 +541,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,
@@ -480,6 +592,69 @@ class Run extends command_base_1.CommandBase {
         const queryString = queryParams.toString();
         return queryString ? `${apiEndpoint}?${queryString}` : apiEndpoint;
     }
+    async uploadVariableFiles(ctx, testSuiteId, token) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), utils_1.UPLOAD_TIMEOUT_MS);
+        try {
+            ctx.configuration.storedValues = ctx.configuration.storedValues || {};
+            const uploads = await Promise.all(ctx.storedValueFileInputs.map(async (input) => ({
+                name: input.name,
+                url: await (0, variable_file_uploader_1.uploadVariableFile)(this.TESTRIGOR_API2_URL, testSuiteId, token, input.file),
+            })));
+            for (const { name, url } of uploads) {
+                ctx.configuration.storedValues[name] = url;
+            }
+        }
+        catch (error) {
+            if (error.name === "AbortError") {
+                throw new Error("Variable files upload timed out. Please check your network connection.");
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    async uploadClientCertificates(ctx, testSuiteId, token, task) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), utils_1.UPLOAD_TIMEOUT_MS);
+        try {
+            ctx.configuration.clientCertificateOverrides =
+                ctx.configuration.clientCertificateOverrides || {};
+            const uploads = await Promise.all(ctx.storedValueCertInputs.map(async (input) => {
+                const uploaded = await (0, certificate_uploader_1.uploadClientCertificate)(this.TESTRIGOR_API2_URL, testSuiteId, token, input.file, input.password);
+                return {
+                    name: input.name,
+                    certificateId: uploaded.certificateId,
+                    info: uploaded.info,
+                };
+            }));
+            for (const { name, certificateId } of uploads) {
+                ctx.configuration.clientCertificateOverrides[name] = certificateId;
+            }
+            const summary = uploads
+                .map(({ name, info }) => {
+                const subject = info?.subject?.commonName || info?.subject?.distinguishedName;
+                const notAfter = info?.notAfter
+                    ? ` (expires ${info.notAfter.slice(0, 10)})`
+                    : "";
+                return subject ? `${name}: ${subject}${notAfter}` : name;
+            })
+                .join("; ");
+            if (summary) {
+                task.title = `Uploaded client certificate(s): ${summary}`;
+            }
+        }
+        catch (error) {
+            if (error.name === "AbortError") {
+                throw new Error("Client certificates upload timed out. Please check your network connection.");
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
     async callRetest(testSuiteId, configuration, token) {
         return (0, node_fetch_commonjs_1.default)(`${this.TESTRIGOR_API_URL}/apps/${testSuiteId}/retest`, {
             method: "POST",
@@ -491,6 +666,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 +857,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 +881,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 +912,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/types.d.ts

@@ -65,3 +65,54 @@ export type ChromeExtensionOverrideItem = {
 export type ChromeExtensionOverridesRequest = {
     chromeExtensions: ChromeExtensionOverrideItem[];
 };
+export type StoredValueFileInput = {
+    name: string;
+    file: string;
+};
+export type StoredValueCertInput = {
+    name: string;
+    file: string;
+    password: string;
+};
+export type ParsedVariables = {
+    textValues: Record<string, string>;
+    fileInputs: StoredValueFileInput[];
+    certInputs: StoredValueCertInput[];
+};
+export type ClientCertificateDistinguishedName = {
+    distinguishedName?: string;
+    commonName?: string;
+};
+export type ClientCertificateInfo = {
+    serialNumber?: string;
+    notBefore?: string;
+    notAfter?: string;
+    issuer?: ClientCertificateDistinguishedName;
+    subject?: ClientCertificateDistinguishedName;
+};
+export type CertificateUploadDataApi2Response = {
+    certificateId: string;
+    info?: ClientCertificateInfo;
+};
+export type UploadedClientCertificate = {
+    certificateId: string;
+    info?: ClientCertificateInfo;
+};
+export type CertificateUploadApi2Response = Api2Wrapper & {
+    data: CertificateUploadDataApi2Response;
+};
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export type FileVariableObject = {
+    type: "FILE";
+    value: string;
+};
+export type CertVariableObject = {
+    type: "CLIENT_CERTIFICATE";
+    value: string;
+    password: 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/certificate-uploader.d.ts

@@ -0,0 +1,2 @@
+import { UploadedClientCertificate } from "../types";
+export declare function uploadClientCertificate(api2BaseUrl: string, testSuiteId: string, token: string, localFilePath: string, password: string): Promise<UploadedClientCertificate>;

package/dist/util/certificate-uploader.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadClientCertificate = void 0;
+const fs = require("fs");
+const path = require("path");
+const node_fetch_commonjs_1 = require("node-fetch-commonjs");
+const type_guards_1 = require("./type-guards");
+async function uploadClientCertificate(api2BaseUrl, testSuiteId, token, localFilePath, password) {
+    const fileName = path.basename(localFilePath);
+    const certBase64 = fs.readFileSync(localFilePath).toString("base64");
+    const response = await (0, node_fetch_commonjs_1.default)(`${api2BaseUrl}/apps/${testSuiteId}/test_data/global_variables/client_certificate`, {
+        method: "POST",
+        body: JSON.stringify({ fileName, certBase64, password }),
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "auth-token": token,
+        },
+    });
+    const responseJson = await response.json();
+    if (!(0, type_guards_1.isCertificateUploadApi2Response)(responseJson)) {
+        throw new Error(`Unexpected response shape from client certificate upload endpoint for '${fileName}'`);
+    }
+    if (!response.ok || responseJson.status !== 200 || !responseJson.data) {
+        throw new Error(`Failed to upload client certificate '${fileName}': ${responseJson.message}`);
+    }
+    return {
+        certificateId: responseJson.data.certificateId,
+        info: responseJson.data.info,
+    };
+}
+exports.uploadClientCertificate = uploadClientCertificate;

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/dist/util/type-guards.d.ts

@@ -0,0 +1,4 @@
+import { CertificateUploadApi2Response, SignedUrlApi2Response } from "../types";
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function isSignedUrlApi2Response(value: unknown): value is SignedUrlApi2Response;
+export declare function isCertificateUploadApi2Response(value: unknown): value is CertificateUploadApi2Response;

package/dist/util/type-guards.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCertificateUploadApi2Response = exports.isSignedUrlApi2Response = exports.isPlainObject = void 0;
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+exports.isPlainObject = isPlainObject;
+function isSignedUrlApi2Response(value) {
+    return isPlainObject(value) && "status" in value;
+}
+exports.isSignedUrlApi2Response = isSignedUrlApi2Response;
+function isCertificateUploadApi2Response(value) {
+    return isPlainObject(value) && "status" in value;
+}
+exports.isCertificateUploadApi2Response = isCertificateUploadApi2Response;

package/dist/util/variable-file-uploader.d.ts

@@ -0,0 +1 @@
+export declare function uploadVariableFile(api2BaseUrl: string, testSuiteId: string, token: string, localFilePath: string): Promise<string>;

package/dist/util/variable-file-uploader.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadVariableFile = void 0;
+const Fs = require("@supercharge/fs");
+const path = require("path");
+const node_fetch_commonjs_1 = require("node-fetch-commonjs");
+const utils_1 = require("./utils");
+const type_guards_1 = require("./type-guards");
+async function uploadVariableFile(api2BaseUrl, testSuiteId, token, localFilePath) {
+    const fileName = path.basename(localFilePath);
+    const fileSize = Fs.statSync(localFilePath).size;
+    const presignedResp = await (0, node_fetch_commonjs_1.default)(`${api2BaseUrl}/apps/${testSuiteId}/test_data/global_variables/file/pre_signed_url`, {
+        method: "POST",
+        body: JSON.stringify({ fileName }),
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "auth-token": token,
+        },
+    });
+    const presignedJson = await presignedResp.json();
+    if (!(0, type_guards_1.isSignedUrlApi2Response)(presignedJson)) {
+        throw new Error(`Unexpected response shape from presigned URL endpoint for '${fileName}'`);
+    }
+    if (!presignedResp.ok ||
+        presignedJson.status !== 200 ||
+        !presignedJson.data) {
+        throw new Error(`Failed to request presigned URL for variable file '${fileName}': ${presignedJson.message}`);
+    }
+    const fileStream = Fs.createReadStream(localFilePath);
+    const putResp = await (0, node_fetch_commonjs_1.default)(presignedJson.data.url, {
+        method: "PUT",
+        body: fileStream,
+        headers: {
+            "Content-length": `${fileSize}`,
+        },
+    });
+    if (!putResp.ok) {
+        throw new Error(`Failed to upload variable file '${fileName}' to S3: ${putResp.statusText}`);
+    }
+    return (0, utils_1.extractUrlWithoutQueryParams)(presignedJson.data.url);
+}
+exports.uploadVariableFile = uploadVariableFile;

package/dist/util/variables-path-parser.d.ts

@@ -0,0 +1,2 @@
+import { JsonValue, ParsedVariables } from "../types";
+export declare function parseVariablesJson(parsed: JsonValue): ParsedVariables;

package/dist/util/variables-path-parser.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVariablesJson = void 0;
+const fs = require("fs");
+const path = require("path");
+const type_guards_1 = require("./type-guards");
+const MAX_FILE_SIZE_BYTES = 100 * 1024 * 1024;
+const MAX_COMBINED_SIZE_BYTES = 100 * 1024 * 1024;
+const MAX_SIZE_LABEL = "100 MB";
+const MAX_CERT_FILE_SIZE_BYTES = 20 * 1024; // 20 KB
+const MAX_CERT_PASSWORD_LENGTH = 100;
+const MAX_CERT_FILENAME_LENGTH = 100;
+const ERROR_ROOT_NOT_OBJECT = "--variables-path must contain a JSON object at the top level";
+const ERROR_COMBINED_SIZE_EXCEEDED = `Variable files combined size exceeds the maximum allowed (${MAX_SIZE_LABEL})`;
+function isUrl(value) {
+    return /^https?:\/\//i.test(value);
+}
+function isFileVariableObject(value) {
+    return ((0, type_guards_1.isPlainObject)(value) &&
+        value.type === "FILE" &&
+        typeof value.value === "string");
+}
+function isCertVariableObject(value) {
+    return ((0, type_guards_1.isPlainObject)(value) &&
+        value.type === "CLIENT_CERTIFICATE" &&
+        typeof value.value === "string" &&
+        typeof value.password === "string");
+}
+function readLocalFileSize(key, filePath) {
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`Variable "${key}": file not found at path "${filePath}"`);
+    }
+    const size = fs.statSync(filePath).size;
+    if (size > MAX_FILE_SIZE_BYTES) {
+        throw new Error(`Variable "${key}": file size exceeds the maximum allowed (${MAX_SIZE_LABEL})`);
+    }
+    return size;
+}
+function validateLocalCertFile(key, value) {
+    if (isUrl(value)) {
+        throw new Error(`Variable "${key}": CLIENT_CERTIFICATE does not support URL values; provide a local .pfx file path`);
+    }
+    if (!fs.existsSync(value)) {
+        throw new Error(`Variable "${key}": file not found at path "${value}"`);
+    }
+    if (!/\.pfx$/i.test(path.basename(value))) {
+        throw new Error(`Variable "${key}": CLIENT_CERTIFICATE requires a .pfx file`);
+    }
+    if (path.basename(value).length > MAX_CERT_FILENAME_LENGTH) {
+        throw new Error(`Variable "${key}": filename is too long (max ${MAX_CERT_FILENAME_LENGTH} chars)`);
+    }
+    if (fs.statSync(value).size > MAX_CERT_FILE_SIZE_BYTES) {
+        throw new Error(`Variable "${key}": certificate file exceeds the maximum allowed (20 KB)`);
+    }
+}
+function parseVariablesJson(parsed) {
+    if (!(0, type_guards_1.isPlainObject)(parsed)) {
+        throw new Error(ERROR_ROOT_NOT_OBJECT);
+    }
+    const textValues = {};
+    const fileInputs = [];
+    const certInputs = [];
+    let combinedSize = 0;
+    for (const [key, raw] of Object.entries(parsed)) {
+        if (typeof raw === "string") {
+            textValues[key] = raw;
+            continue;
+        }
+        if (!(0, type_guards_1.isPlainObject)(raw)) {
+            throw new Error(`Variable "${key}": expected a string or { type: "FILE", value: "..." }`);
+        }
+        if (raw.type === "FILE" && raw.password !== undefined) {
+            throw new Error(`Variable "${key}": "password" field is only valid for CLIENT_CERTIFICATE. Did you mean type:"CLIENT_CERTIFICATE"?`);
+        }
+        if (raw.type === "FILE") {
+            if (!isFileVariableObject(raw)) {
+                throw new Error(`Variable "${key}": missing or empty "value" for type:FILE`);
+            }
+            const value = raw.value.trim();
+            if (value.length === 0) {
+                throw new Error(`Variable "${key}": missing or empty "value" for type:FILE`);
+            }
+            if (isUrl(value)) {
+                textValues[key] = value;
+                continue;
+            }
+            combinedSize += readLocalFileSize(key, value);
+            if (combinedSize > MAX_COMBINED_SIZE_BYTES) {
+                throw new Error(ERROR_COMBINED_SIZE_EXCEEDED);
+            }
+            fileInputs.push({ name: key, file: value });
+            continue;
+        }
+        if (raw.type === "CLIENT_CERTIFICATE") {
+            if (!isCertVariableObject(raw)) {
+                if (typeof raw.value !== "string" || raw.value.trim().length === 0) {
+                    throw new Error(`Variable "${key}": missing or empty "value" for type:CLIENT_CERTIFICATE`);
+                }
+                throw new Error(`Variable "${key}": missing or empty "password" for type:CLIENT_CERTIFICATE`);
+            }
+            const value = raw.value.trim();
+            if (value.length === 0) {
+                throw new Error(`Variable "${key}": missing or empty "value" for type:CLIENT_CERTIFICATE`);
+            }
+            if (raw.password.length === 0) {
+                throw new Error(`Variable "${key}": missing or empty "password" for type:CLIENT_CERTIFICATE`);
+            }
+            if (raw.password.length > MAX_CERT_PASSWORD_LENGTH) {
+                throw new Error(`Variable "${key}": "password" exceeds the maximum length of ${MAX_CERT_PASSWORD_LENGTH} characters`);
+            }
+            validateLocalCertFile(key, value);
+            certInputs.push({
+                name: key,
+                file: value,
+                password: raw.password,
+            });
+            continue;
+        }
+        if (typeof raw.type === "string" && raw.type.toUpperCase() === "FILE") {
+            throw new Error(`Variable "${key}": unsupported type "${String(raw.type)}". Only "FILE" (uppercase) and "CLIENT_CERTIFICATE" are supported.`);
+        }
+        throw new Error(`Variable "${key}": unsupported type "${String(raw.type)}". Only "FILE" and "CLIENT_CERTIFICATE" are supported.`);
+    }
+    return { textValues, fileInputs, certInputs };
+}
+exports.parseVariablesJson = parseVariablesJson;

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.42-beta",
+  "version": "0.0.45-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.45-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"