@testrigor/testrigor-cli 0.0.42-beta

package/dist/config/environments.d.ts

@@ -0,0 +1,7 @@
+export type Environment = "prod";
+interface EnvironmentConfig {
+    TESTRIGOR_WEB_URL: string;
+    TESTRIGOR_API_URL: string;
+}
+declare const environments: Record<Environment, EnvironmentConfig>;
+export { environments };

package/dist/config/environments.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.environments = void 0;
+const environments = {
+    prod: {
+        TESTRIGOR_WEB_URL: "https://app.testrigor.com",
+        TESTRIGOR_API_URL: "https://api2.testrigor.com",
+    },
+};
+exports.environments = environments;

package/dist/flags/chrome-extension.d.ts

@@ -0,0 +1,4 @@
+export declare const ChromeExtensionFlag: import("@oclif/core/lib/interfaces/parser").FlagDefinition<{
+    name: string;
+    file: string;
+}, Record<string, unknown>>;

package/dist/flags/chrome-extension.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChromeExtensionFlag = void 0;
+const core_1 = require("@oclif/core");
+const fs = require("fs");
+const path = require("path");
+const utils_1 = require("../util/utils");
+let totalChromeExtensionSize = 0;
+exports.ChromeExtensionFlag = core_1.Flags.custom({
+    description: 'Chrome extension: "name=EXT_NAME file=PATH_TO_CRX"',
+    multiple: true,
+    parse: async (input) => {
+        // The 'file=' acts as a delimiter for the name value
+        // Supports quoted paths: file="path with spaces.crx" or file='path.crx'
+        const fileMatch = input.match(/\bfile=(?:["'](.+?)["']|(.+))$/i);
+        const nameMatch = input.match(/^name=(.+?)\s+file=/i);
+        if (!nameMatch || !nameMatch[1]) {
+            throw new Error("--chrome-extension requires: name=EXT_NAME");
+        }
+        if (!fileMatch) {
+            throw new Error("--chrome-extension requires: file=PATH_TO_CRX");
+        }
+        const name = nameMatch[1].trim();
+        if (!name) {
+            throw new Error("--chrome-extension requires a non-empty name");
+        }
+        // Extract file path from either quoted (group 1) or unquoted (group 2) match
+        const file = (fileMatch[1] || fileMatch[2] || "").trim();
+        if (!file.toLowerCase().endsWith(".crx")) {
+            throw new Error(`File '${path.basename(file)}': invalid extension. Allowed: .crx`);
+        }
+        if (!fs.existsSync(file)) {
+            throw new Error(`Chrome extension file not found: ${file}`);
+        }
+        const fileSize = fs.statSync(file).size;
+        if (fileSize > utils_1.MAX_FILE_SIZE_100_MB) {
+            throw new Error(`File '${path.basename(file)}': size exceeds maximum allowed (100 MB)`);
+        }
+        totalChromeExtensionSize += fileSize;
+        if (totalChromeExtensionSize > utils_1.MAX_FILE_SIZE_100_MB) {
+            throw new Error("Chrome extensions combined size exceeds maximum allowed (100 MB)");
+        }
+        return { name, file: path.resolve(file) };
+    },
+});

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from "@oclif/core";

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+var core_1 = require("@oclif/core");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });

package/dist/types.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="node" />
+import { ReadStream } from "fs";
+export type RetestResponse = {
+    result: string;
+    msg: string;
+    errName?: string;
+    taskId?: string;
+    queueId?: string;
+};
+export type StatusResponse = {
+    detailsUrl?: string;
+    status?: string;
+};
+export type RetestSignedUrlApi2Request = {
+    fileName: string;
+};
+export type Api2Wrapper = {
+    status: number;
+    message: string;
+    errors?: string[];
+    path?: string;
+    data?: object;
+};
+export type RetestDataApi2Response = {
+    taskId?: string;
+    queueId?: string;
+};
+export type RetestApi2Response = Api2Wrapper & {
+    data: RetestDataApi2Response;
+};
+export type SignedUrlDataApi2Response = {
+    url: string;
+    fileName: string;
+};
+export type SignedUrlApi2Response = Api2Wrapper & {
+    data: SignedUrlDataApi2Response;
+};
+export type FileProperties = {
+    fileName: string;
+    fileSize: number;
+};
+export type TestCase = {
+    testCaseUuid?: string;
+    customSteps: string;
+    description: string;
+    labels?: string[];
+    datasetName?: string;
+};
+export type Rule = {
+    steps: string;
+    name: string;
+    labels: string[];
+};
+export type ChromeExtensionInput = {
+    name: string;
+    file: string;
+};
+/**
+ * Represents a single chrome extension override with its binary file.
+ */
+export type ChromeExtensionOverrideItem = {
+    name: string;
+    file: ReadStream;
+};
+export type ChromeExtensionOverridesRequest = {
+    chromeExtensions: ChromeExtensionOverrideItem[];
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/util/config.d.ts

@@ -0,0 +1,33 @@
+export type TestRigorConfig = {
+    authToken?: string;
+    defaultTestSuiteId?: string;
+    [key: string]: any;
+};
+export type ConfigPath = {
+    homeDir: string;
+    configPath: string;
+};
+/**
+ * Get the paths for testRigor configuration
+ */
+export declare function getConfigPath(): ConfigPath;
+/**
+ * Read testRigor configuration from ~/.testrigor/testrigor.yml
+ */
+export declare function readConfig(): Promise<TestRigorConfig>;
+/**
+ * Write testRigor configuration to ~/.testrigor/testrigor.yml
+ */
+export declare function writeConfig(config: TestRigorConfig): Promise<void>;
+/**
+ * Read a specific property from testRigor configuration
+ */
+export declare function readConfigProperty<T extends keyof TestRigorConfig>(property: T): Promise<TestRigorConfig[T] | null>;
+/**
+ * Update a specific property in testRigor configuration
+ */
+export declare function updateConfigProperty<T extends keyof TestRigorConfig>(property: T, value: TestRigorConfig[T]): Promise<void>;
+/**
+ * Delete a specific property from testRigor configuration
+ */
+export declare function deleteConfigProperty<T extends keyof TestRigorConfig>(property: T): Promise<void>;

package/dist/util/config.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteConfigProperty = exports.updateConfigProperty = exports.readConfigProperty = exports.writeConfig = exports.readConfig = exports.getConfigPath = void 0;
+const core_1 = require("@oclif/core");
+const Fs = require("@supercharge/fs");
+const path = require("path");
+const yaml_1 = require("yaml");
+const utils_1 = require("./utils");
+/**
+ * Get the paths for testRigor configuration
+ */
+function getConfigPath() {
+    const homeDir = (0, utils_1.getHomeDir)();
+    const configPath = path.join(homeDir, "testrigor.yml");
+    return { homeDir, configPath };
+}
+exports.getConfigPath = getConfigPath;
+/**
+ * Read testRigor configuration from ~/.testrigor/testrigor.yml
+ */
+async function readConfig() {
+    const { configPath } = getConfigPath();
+    if (!(await Fs.pathExists(configPath))) {
+        return {};
+    }
+    try {
+        const content = await Fs.content(configPath);
+        return (0, yaml_1.parse)(content.toString()) || {};
+    }
+    catch (error) {
+        core_1.ux.warn(`Warning: Found testrigor.yml at "${configPath}" but could not read/parse it.\n` +
+            `Error: ${error instanceof Error ? error.message : String(error)}\n` +
+            "Please check your configuration file.");
+        return {};
+    }
+}
+exports.readConfig = readConfig;
+/**
+ * Write testRigor configuration to ~/.testrigor/testrigor.yml
+ */
+async function writeConfig(config) {
+    const { homeDir, configPath } = getConfigPath();
+    // Ensure the config directory exists
+    if (!(await Fs.pathExists(homeDir))) {
+        await Fs.ensureDir(homeDir);
+    }
+    // Avoid writing empty objects as "{}"
+    const configContent = Object.keys(config).length > 0 ? (0, yaml_1.stringify)(config) : "";
+    if (configContent.trim() === "") {
+        await Fs.writeFile(configPath, "");
+    }
+    else {
+        await Fs.writeFile(configPath, configContent);
+    }
+}
+exports.writeConfig = writeConfig;
+/**
+ * Read a specific property from testRigor configuration
+ */
+async function readConfigProperty(property) {
+    const config = await readConfig();
+    return config[property] || null;
+}
+exports.readConfigProperty = readConfigProperty;
+/**
+ * Update a specific property in testRigor configuration
+ */
+async function updateConfigProperty(property, value) {
+    const config = await readConfig();
+    if (value === null || value === undefined) {
+        delete config[property];
+    }
+    else {
+        config[property] = value;
+    }
+    await writeConfig(config);
+}
+exports.updateConfigProperty = updateConfigProperty;
+/**
+ * Delete a specific property from testRigor configuration
+ */
+async function deleteConfigProperty(property) {
+    const config = await readConfig();
+    delete config[property];
+    await writeConfig(config);
+}
+exports.deleteConfigProperty = deleteConfigProperty;

package/dist/util/parser.d.ts

@@ -0,0 +1,4 @@
+import { Rule, TestCase } from "../types";
+export declare function parseTestCases(path: string): Promise<TestCase[]>;
+export declare function parseRules(path: string): Promise<Rule[]>;
+export declare function parseSettings(path: string): Promise<object>;

package/dist/util/parser.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSettings = exports.parseRules = exports.parseTestCases = void 0;
+const Fs = require("@supercharge/fs");
+const glob_1 = require("glob");
+const yaml_1 = require("yaml");
+const utils_1 = require("./utils");
+async function parseTestCases(path) {
+    const result = [];
+    const files = await (0, glob_1.glob)(path, { withFileTypes: true });
+    for (const file of files) {
+        if (file.isFile()) {
+            const content = await Fs.content(file.fullpath());
+            if ((0, utils_1.isYamlFile)(file.name)) {
+                const json = (0, yaml_1.parse)(content.toString());
+                const testCase = {
+                    customSteps: json.customSteps,
+                    description: (0, utils_1.removeExtension)(file.name),
+                };
+                if (json.testCaseUuid) {
+                    testCase.testCaseUuid = json.testCaseUuid;
+                }
+                if (json.labels) {
+                    testCase.labels = json.labels;
+                }
+                if (json.datasetName) {
+                    testCase.datasetName = json.datasetName;
+                }
+                result.push(testCase);
+            }
+            if ((0, utils_1.isTextFile)(file.name)) {
+                const testCase = {
+                    customSteps: content,
+                    description: (0, utils_1.removeExtension)(file.name),
+                };
+                result.push(testCase);
+            }
+        }
+    }
+    return result;
+}
+exports.parseTestCases = parseTestCases;
+async function parseRules(path) {
+    const result = [];
+    const files = await (0, glob_1.glob)(path, { withFileTypes: true });
+    for (const file of files) {
+        if (file.isFile()) {
+            const content = await Fs.content(file.fullpath());
+            if ((0, utils_1.isYamlFile)(file.name)) {
+                const json = (0, yaml_1.parse)(content.toString());
+                const ruleName = (0, utils_1.removeExtension)(file.name);
+                const rule = {
+                    steps: json.steps,
+                    name: ruleName,
+                    labels: json.labels?.length ? json.labels : [json.name],
+                };
+                result.push(rule);
+            }
+            if ((0, utils_1.isTextFile)(file.name)) {
+                const ruleName = (0, utils_1.removeExtension)(file.name);
+                const rule = {
+                    steps: content,
+                    name: ruleName,
+                    labels: [ruleName],
+                };
+                result.push(rule);
+            }
+        }
+    }
+    return result;
+}
+exports.parseRules = parseRules;
+async function parseSettings(path) {
+    const content = await Fs.content(path);
+    if ((0, utils_1.isYamlFile)(path)) {
+        return (0, yaml_1.parse)(content.toString());
+    }
+    if ((0, utils_1.isJsonFile)(path)) {
+        return JSON.parse(content.toString());
+    }
+    return {};
+}
+exports.parseSettings = parseSettings;

package/dist/util/request-builder.d.ts

@@ -0,0 +1,11 @@
+import * as FormData from "form-data";
+import { ChromeExtensionInput } from "../types";
+export interface ChromeExtensionFormDataResult {
+    form: FormData;
+    cleanup: () => void;
+}
+/**
+ * Converts ChromeExtensionInput[] -> ChromeExtensionOverridesRequest -> FormData
+ * Returns both the FormData and a cleanup function to close streams.
+ */
+export declare function buildChromeExtensionFormData(chromeExtensions: ChromeExtensionInput[]): ChromeExtensionFormDataResult;

package/dist/util/request-builder.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildChromeExtensionFormData = void 0;
+const FormData = require("form-data");
+const Fs = require("@supercharge/fs");
+const path = require("path");
+function toChromeExtensionOverrideItem(input) {
+    try {
+        return {
+            name: input.name,
+            file: Fs.createReadStream(input.file),
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to read chrome extension file "${input.file}": ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function toChromeExtensionOverridesRequest(extensionInputs) {
+    const chromeExtensions = extensionInputs.map(toChromeExtensionOverrideItem);
+    const streams = chromeExtensions.map((item) => item.file);
+    return {
+        request: { chromeExtensions },
+        streams,
+    };
+}
+/**
+ * Converts ChromeExtensionInput[] -> ChromeExtensionOverridesRequest -> FormData
+ * Returns both the FormData and a cleanup function to close streams.
+ */
+function buildChromeExtensionFormData(chromeExtensions) {
+    const { request, streams } = toChromeExtensionOverridesRequest(chromeExtensions);
+    const form = new FormData();
+    request.chromeExtensions.forEach((ext, index) => {
+        form.append(`chromeExtensions[${index}].name`, ext.name);
+        const fileName = path.basename(chromeExtensions[index].file);
+        form.append(`chromeExtensions[${index}].file`, ext.file, {
+            filename: fileName,
+        });
+    });
+    const cleanup = () => {
+        streams.forEach((stream) => {
+            if (!stream.destroyed) {
+                stream.destroy();
+            }
+        });
+    };
+    return { form, cleanup };
+}
+exports.buildChromeExtensionFormData = buildChromeExtensionFormData;

package/dist/util/trtc.d.ts

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

package/dist/util/trtc.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.download = void 0;
+const Fs = require("@supercharge/fs");
+const fs = require("fs");
+const node_fetch_commonjs_1 = require("node-fetch-commonjs");
+const os = require("os");
+const path = require("path");
+const tar = require("tar-stream");
+const unzip = require("unzip-stream");
+const zlib = require("zlib");
+const core_1 = require("@oclif/core");
+const FILE_EXTENSION = {
+    darwin: "tar.gz",
+    linux: "tar.gz",
+    win32: "zip",
+};
+const FILE_NAME = {
+    darwin: "darwin",
+    linux: "linux",
+    win32: "windows",
+};
+const ARCHITECTURE_MAP = {
+    x64: "amd64",
+    arm64: "arm64",
+};
+const VERSION = "2.3.15";
+function getFolderName() {
+    const platform = os.platform();
+    const architecture = os.arch();
+    const fileName = FILE_NAME[platform];
+    const arch = ARCHITECTURE_MAP[architecture];
+    if (arch && fileName) {
+        return `trtc_${VERSION}_${fileName}_${arch}`;
+    }
+    throw new Error(`Unsupported platform ${platform} or architecture ${architecture}`);
+}
+function getUrl() {
+    const platform = os.platform();
+    const architecture = os.arch();
+    const extension = FILE_EXTENSION[platform];
+    const folderName = getFolderName();
+    if (folderName && extension) {
+        return `https://testrigor-storage.s3.amazonaws.com/tunneling-client/${VERSION}/${folderName}.${extension}`;
+    }
+    throw new Error(`Unsupported platform ${platform} or architecture ${architecture}`);
+}
+async function extractZip(dir, stream) {
+    return new Promise((resolve, reject) => {
+        stream
+            .pipe(unzip.Extract({ path: dir }))
+            .on("close", () => resolve(path.join(dir, getFolderName())))
+            .on("error", reject);
+    });
+}
+async function extractTar(dir, stream) {
+    const extract = tar.extract();
+    return new Promise((resolve, reject) => {
+        extract.on("error", reject);
+        extract.on("entry", (header, stream, next) => {
+            const entryPath = path.join(dir, header.name);
+            const opts = { mode: header.mode };
+            switch (header.type) {
+                case "directory":
+                    Fs.ensureDir(entryPath, opts);
+                    next();
+                    break;
+                case "file": {
+                    const writeStream = fs.createWriteStream(entryPath);
+                    stream.pipe(writeStream);
+                    writeStream.on("close", () => {
+                        try {
+                            fs.chmodSync(entryPath, header.mode || 0o644);
+                        }
+                        catch (error) {
+                            core_1.ux.warn(`Could not set permissions for ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    });
+                    break;
+                }
+                case "symlink":
+                    // ignore symlinks since they will not work on windows
+                    next();
+                    break;
+                default:
+                    throw new Error(header.type);
+            }
+            stream.resume();
+            stream.on("end", next);
+        });
+        extract.on("finish", () => resolve(path.join(dir, getFolderName())));
+        stream.pipe(zlib.createGunzip()).pipe(extract);
+    });
+}
+async function download(dir) {
+    const response = await (0, node_fetch_commonjs_1.default)(getUrl());
+    if (!response.ok) {
+        throw new Error(`unexpected response ${response.statusText}`);
+    }
+    const stream = response.body;
+    if (stream == null) {
+        throw new Error("unexpected null response body");
+    }
+    if (os.platform() === "win32") {
+        return extractZip(dir, stream);
+    }
+    return extractTar(dir, stream);
+}
+exports.download = download;

package/dist/util/tunnel.d.ts

@@ -0,0 +1,13 @@
+export default class Tunnel {
+    private static readonly BINARY_DIRECTORY;
+    private running;
+    private process;
+    private port;
+    private binaryPath?;
+    constructor();
+    initialize(): Promise<void>;
+    start(minPort: number, maxPort: number): Promise<void>;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    getPort(): number;
+}

package/dist/util/tunnel.js

@@ -0,0 +1,102 @@
+"use strict";
+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");
+function randomPort(min, max) {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+}
+async function updateConfig(dir, port) {
+    const parentDir = path.dirname(dir);
+    const configPath = `${parentDir}/config.toml`;
+    const newConfigContent = `[[proxies]]
+name = "http_proxy_${port}"
+type = "tcp"
+remotePort = ${port}
+[proxies.plugin]
+type = "http_proxy"`;
+    return Fs.writeFile(configPath, newConfigContent);
+}
+async function startTrtc(trtc, command) {
+    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
+        if (!Fs.pathExistsSync(binaryPath)) {
+            reject(new Error(`Binary not found at ${binaryPath}`));
+            return;
+        }
+        const tunnelProcess = childProcess.spawn(binaryPath, [], {
+            cwd: workingDir,
+        });
+        tunnelProcess.stdout.on("data", (data) => {
+            const dataString = data.toString();
+            if (dataString.includes("start proxy success")) {
+                resolve(tunnelProcess);
+            }
+            else if (dataString.includes("port already used")) {
+                tunnelProcess.kill("SIGINT");
+                reject(new Error("Port already used"));
+            }
+        });
+        tunnelProcess.stderr.on("data", (data) => {
+            reject(new Error(`TRTC error: ${data.toString()}`));
+        });
+        tunnelProcess.on("error", (error) => {
+            reject(error);
+        });
+        tunnelProcess.on("exit", (code, signal) => {
+            if (code !== 0) {
+                reject(new Error(`TRTC exited with code ${code}`));
+            }
+        });
+    });
+}
+class Tunnel {
+    constructor() {
+        this.running = false;
+        this.process = null;
+        this.port = 0;
+    }
+    async initialize() {
+        const directory = await (0, utils_1.createDirectory)(Tunnel.BINARY_DIRECTORY);
+        this.binaryPath = await (0, trtc_1.download)(directory);
+    }
+    async start(minPort, maxPort) {
+        if (this.binaryPath == null) {
+            throw new Error("Could not download the trtc binary");
+        }
+        const command = os.platform() === "win32" ? "trtc.exe" : "trtc";
+        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);
+                break;
+            }
+            catch (e) {
+                maxTries--;
+            }
+        }
+        if (maxTries === 0) {
+            throw new Error("Could not start trtc process");
+        }
+        this.running = true;
+    }
+    async stop() {
+        if (this.isRunning()) {
+            this.process?.kill("SIGINT");
+        }
+    }
+    isRunning() {
+        return this.running;
+    }
+    getPort() {
+        return this.port;
+    }
+}
+exports.default = Tunnel;
+Tunnel.BINARY_DIRECTORY = "trtc";

package/dist/util/utils.d.ts

@@ -0,0 +1,16 @@
+export declare const MAX_FILE_SIZE_100_MB: number;
+export declare const UPLOAD_TIMEOUT_MS: number;
+export declare function createDirectory(name: string): Promise<string>;
+export declare function getHomeDir(): string;
+export declare function pathExists(name: string | undefined): Promise<boolean>;
+export declare function isRunningOnCi(): any;
+export declare function rendererToUse(): "default" | "verbose";
+export declare function isYamlFile(fileName: string): boolean;
+export declare function isTextFile(fileName: string): boolean;
+export declare function isJsonFile(fileName: string): boolean;
+export declare function isValidFileExtensionToUpload(fileName: string): boolean;
+export declare function getExtensionLength(fileName: string): 0 | 4 | 5;
+export declare function removeExtension(fileName: string): string;
+export declare function extractUrlWithoutQueryParams(urlString: string): string;
+export declare function extractRunIdFromDetailsUrl(detailsUrl: string | undefined): string;
+export declare function isValidUrl(url: string): boolean;