wdio-lambdatest-service-sdk 5.0.0 → 5.1.0

package/lib/cli/setup.js

@@ -0,0 +1,174 @@
+/**
+ * Setup command logic: Inject LambdaTest service into WDIO config files.
+ */
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+
+// SDK path relative to this file (lib/cli/setup.js -> root)
+const sdkPath = path.resolve(__dirname, '../..');
+
+/**
+ * Parse existing user/key from config file content (supports commented lines).
+ * @param {string} content - File content
+ * @returns {{ userVal: string, keyVal: string }}
+ */
+function parseCredentialsFromContent(content) {
+    let userVal = 'process.env.LT_USERNAME';
+    let keyVal = 'process.env.LT_ACCESS_KEY';
+    const userMatch = content.match(/^\s*\/{0,2}\s*user:\s*(.*?),/m);
+    if (userMatch) userVal = userMatch[1].trim();
+    const keyMatch = content.match(/^\s*\/{0,2}\s*key:\s*(.*?),/m);
+    if (keyMatch) keyVal = keyMatch[1].trim();
+    return { userVal, keyVal };
+}
+
+/**
+ * Update a single WDIO config file: inject service, ensure path, set logLevel, comment user/key.
+ * Avoids double-injection by checking for existing wdio-lambdatest-service.
+ */
+function updateConfigFile(filePath) {
+    let content;
+    try {
+        content = fs.readFileSync(filePath, 'utf8');
+    } catch (e) {
+        console.error(chalk.red(`  ✖ Failed to read ${filePath}:`), e.message);
+        throw new Error(`Failed to read ${filePath}`);
+    }
+
+    const relativePath = path.relative(process.cwd(), filePath);
+    console.log(chalk.dim(`  • Processing: `) + relativePath);
+
+    const { userVal, keyVal } = parseCredentialsFromContent(content);
+
+    let relativeSdkPath = path.relative(path.dirname(filePath), sdkPath);
+    relativeSdkPath = relativeSdkPath.replace(/\\/g, '/');
+
+    const serviceEntry = `[path.join(__dirname, '${relativeSdkPath}'), { user: ${userVal}, key: ${keyVal} }]`;
+
+    if (content.includes('wdio-lambdatest-service')) {
+        const emptyOptionsRegex = /\[path\.join\(__dirname, '.*?wdio-lambdatest-service'\), \{\}\]/;
+        if (emptyOptionsRegex.test(content)) {
+            console.log(chalk.yellow(`    ⚠ Fixing missing credentials in: `) + relativePath);
+            content = content.replace(emptyOptionsRegex, serviceEntry);
+            content = content.replace(/logLevel: ['"]info['"]/, "logLevel: 'error'");
+            try {
+                fs.writeFileSync(filePath, content);
+            } catch (e) {
+                console.error(chalk.red(`  ✖ Failed to write ${filePath}:`), e.message);
+                throw new Error(`Failed to write ${filePath}`);
+            }
+            console.log(chalk.green(`    ✔ Successfully repaired `) + relativePath);
+        } else {
+            console.log(chalk.dim(`    - Skipping (already correct): `) + relativePath);
+        }
+        return;
+    }
+
+    console.log(chalk.cyan(`    → Updating: `) + relativePath);
+
+    if (!content.includes("require('path')")) {
+        content = "const path = require('path');\n" + content;
+    }
+
+    if (content.includes('services: [')) {
+        content = content.replace('services: [', `services: [\n        ${serviceEntry},`);
+    } else {
+        content = content.replace('exports.config = {', `exports.config = {\n    services: [\n        ${serviceEntry}\n    ],`);
+    }
+
+    if (content.includes('logLevel:')) {
+        content = content.replace(/logLevel:.*,/, "logLevel: 'error',");
+    } else {
+        content = content.replace('exports.config = {', `exports.config = {\n    logLevel: 'error',`);
+    }
+
+    content = content.replace(/^(\s*)user:/gm, '$1// user:');
+    content = content.replace(/^(\s*)key:/gm, '$1// key:');
+
+    try {
+        fs.writeFileSync(filePath, content);
+    } catch (e) {
+        console.error(chalk.red(`  ✖ Failed to write ${filePath}:`), e.message);
+        throw new Error(`Failed to write ${filePath}`);
+    }
+    console.log(chalk.green(`    ✔ Successfully updated `) + relativePath);
+}
+
+function traverseDirectory(dir) {
+    if (!fs.existsSync(dir)) {
+        console.error(chalk.red(`✖ Directory not found: ${dir}`));
+        throw new Error(`Directory not found: ${dir}`);
+    }
+
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+        const fullPath = path.join(dir, file);
+        let stat;
+        try {
+            stat = fs.statSync(fullPath);
+        } catch (e) {
+            console.error(chalk.dim(`  ! Cannot read ${fullPath}: ${e.message}`));
+            continue;
+        }
+        if (stat.isDirectory()) {
+            if (file !== 'node_modules' && file !== '.git') {
+                traverseDirectory(fullPath);
+            }
+        } else if (file.endsWith('.conf.js')) {
+            updateConfigFile(fullPath);
+        }
+    }
+}
+
+function printBanner() {
+    console.log();
+    console.log(chalk.cyan.bold('╭─────────────────────────────────────╮'));
+    console.log(chalk.cyan.bold('│') + '     🚀 ' + chalk.bold('LambdaTest WDIO Setup') + '     ' + chalk.cyan.bold('│'));
+    console.log(chalk.cyan.bold('╰─────────────────────────────────────╯'));
+    console.log();
+}
+
+/**
+ * Run the setup command.
+ * @param {string|undefined} targetPath - Path to directory containing .conf.js files. If undefined, prompts interactively.
+ * @returns {Promise<void>}
+ */
+async function runSetup(targetPath) {
+    printBanner();
+
+    let resolvedPath;
+
+    if (targetPath) {
+        resolvedPath = path.resolve(targetPath.trim());
+    } else {
+        // Interactive mode using inquirer
+        const answers = await inquirer.default.prompt([
+            {
+                type: 'input',
+                name: 'path',
+                message: 'Where are your test scripts located?',
+                default: './android-sample',
+                validate: (input) => {
+                    if (!input || input.trim() === '') {
+                        return 'Please enter a valid path';
+                    }
+                    return true;
+                }
+            }
+        ]);
+        resolvedPath = path.resolve(answers.path.trim());
+    }
+
+    console.log(chalk.cyan('→ Scanning:'), chalk.dim(resolvedPath));
+    console.log();
+
+    traverseDirectory(resolvedPath);
+
+    console.log();
+    console.log(chalk.green.bold('✔ Done scanning directories!'));
+    console.log();
+}
+
+module.exports = { runSetup };

package/lib/cli/style.js

@@ -0,0 +1,57 @@
+/**
+ * Shared style utilities using Chalk for CLI output.
+ * Provides consistent, beautiful terminal styling.
+ */
+const chalk = require('chalk');
+
+const style = {
+    // Colors
+    reset: chalk.reset,
+    bold: chalk.bold,
+    dim: chalk.dim,
+    cyan: chalk.cyan,
+    green: chalk.green,
+    yellow: chalk.yellow,
+    red: chalk.red,
+    blue: chalk.blue,
+    magenta: chalk.magenta,
+    gray: chalk.gray,
+    white: chalk.white,
+
+    // Combinations
+    success: chalk.green.bold,
+    error: chalk.red.bold,
+    warning: chalk.yellow.bold,
+    info: chalk.cyan.bold,
+    highlight: chalk.cyan,
+    muted: chalk.dim,
+
+    // Symbols
+    symbols: {
+        success: chalk.green('✔'),
+        error: chalk.red('✖'),
+        warning: chalk.yellow('⚠'),
+        info: chalk.cyan('ℹ'),
+        arrow: chalk.cyan('→'),
+        bullet: chalk.dim('•')
+    },
+
+    // Helper functions
+    title: (text) => chalk.cyan.bold(text),
+    subtitle: (text) => chalk.dim(text),
+    label: (text) => chalk.bold(text),
+    value: (text) => chalk.dim(text),
+    path: (text) => chalk.dim(text),
+    command: (text) => chalk.green(text),
+    
+    // Box drawing
+    box: (title) => {
+        const line = '─'.repeat(title.length + 4);
+        return `${chalk.cyan('┌' + line + '┐')}\n${chalk.cyan('│')}  ${chalk.bold(title)}  ${chalk.cyan('│')}\n${chalk.cyan('└' + line + '┘')}`;
+    },
+
+    // Banner
+    banner: (text) => chalk.cyan.bold(`\n--- ${text} ---\n`)
+};
+
+module.exports = style;

package/package.json

@@ -1,9 +1,19 @@
 {
   "name": "wdio-lambdatest-service-sdk",
-  "version": "5.0.0",
-  "description": "WebdriverIO service for LambdaTest integration",
+  "version": "5.1.0",
+  "description": "WebdriverIO service and CLI for LambdaTest Appium & browser automation",
   "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LambdaTest/wdio-lambdatest-service"
+  },
+  "homepage": "https://github.com/LambdaTest/wdio-lambdatest-service#readme",
+  "bugs": {
+    "url": "https://github.com/LambdaTest/wdio-lambdatest-service/issues"
+  },
   "bin": {
+    "wdio-lt": "bin/cli.js",
+    "wdio-lambdatest": "bin/cli.js",
     "wdio-lambdatest-setup": "bin/setup.js",
     "wdio-lambdatest-generator": "bin/generate-config.js"
   },
@@ -15,15 +25,25 @@
     "wdio",
     "lambdatest",
     "service",
-    "sdk"
+    "sdk",
+    "cli",
+    "bun",
+    "commander",
+    "inquirer"
   ],
   "author": "",
   "license": "ISC",
+  "dependencies": {
+    "chalk": "4",
+    "commander": "^14.0.2",
+    "inquirer": "^13.2.2"
+  },
   "peerDependencies": {
     "@wdio/cli": ">=5.0.0",
     "webdriverio": ">=5.0.0"
   },
   "engines": {
-    "node": ">=10.0.0"
+    "node": ">=18.0.0",
+    "bun": ">=1.0.0"
   }
 }

package/src/launcher.js

@@ -1,3 +1,48 @@
+const LT_OPTIONS_KEY = 'lt:options';
+
+/**
+ * Resolve credentials from service options and env. Prefers options.user/key, then username/accessKey, then env.
+ * @param {object} options - Service options (user, key, username, accessKey)
+ * @param {object} config - WDIO config (may already have user/key from elsewhere)
+ * @returns {{ user: string|undefined, key: string|undefined }}
+ */
+function resolveCredentials(options, config) {
+    let user = options.user || options.username || config.user;
+    let key = options.key || options.accessKey || config.key;
+    if (!user) user = process.env.LT_USERNAME;
+    if (!key) key = process.env.LT_ACCESS_KEY;
+    return { user, key };
+}
+
+/**
+ * Apply credentials to WDIO config (for Basic Auth).
+ * @param {object} config - WDIO config (mutated)
+ * @param {{ user: string|undefined, key: string|undefined }} credentials
+ */
+function applyCredentialsToConfig(config, credentials) {
+    if (credentials.user) config.user = credentials.user;
+    if (credentials.key) config.key = credentials.key;
+}
+
+/**
+ * Apply credentials to each capability (JSONWP and W3C lt:options).
+ * @param {Array<object>} capabilities - List of capability objects (mutated)
+ * @param {{ user: string|undefined, key: string|undefined }} credentials
+ */
+function applyCredentialsToCapabilities(capabilities, credentials) {
+    const { user, key } = credentials;
+    if (!user || !key) return;
+
+    capabilities.forEach((cap) => {
+        if (!cap.user) cap.user = user;
+        if (!cap.accessKey) cap.accessKey = key;
+        const ltOpts = cap[LT_OPTIONS_KEY];
+        if (ltOpts) {
+            if (!ltOpts.username) ltOpts.username = user;
+            if (!ltOpts.accessKey) ltOpts.accessKey = key;
+        }
+    });
+}
 
 module.exports = class LambdaTestLauncher {
     constructor(serviceOptions, capabilities, config) {
@@ -8,35 +53,13 @@ module.exports = class LambdaTestLauncher {
     onPrepare(config, capabilities) {
         console.log('[LambdaTest Service] Processing credentials...');
 
-        // 1. Update Main Config (for WDIO Basic Auth)
-        if (this.options.username) config.user = this.options.username;
-        if (this.options.accessKey) config.key = this.options.accessKey;
-        if (this.options.user) config.user = this.options.user;
-        if (this.options.key) config.key = this.options.key;
-
-        // Fallback to Env Vars
-        if (!config.user) config.user = process.env.LT_USERNAME;
-        if (!config.key) config.key = process.env.LT_ACCESS_KEY;
-
-        // 2. Update Capabilities (Explicitly pass credentials to caps)
-        // This ensures that even if Basic Auth fails or is missed, 
-        // the grid sees them in the capabilities.
-        const user = config.user;
-        const key = config.key;
-
-        if (user && key) {
-            const capsList = Array.isArray(capabilities) ? capabilities : [capabilities];
-            capsList.forEach(cap => {
-                // Legacy JSONWP
-                if (!cap.user) cap.user = user;
-                if (!cap.accessKey) cap.accessKey = key;
-
-                // W3C Support (lt:options)
-                if (cap['lt:options']) {
-                    if (!cap['lt:options'].username) cap['lt:options'].username = user;
-                    if (!cap['lt:options'].accessKey) cap['lt:options'].accessKey = key;
-                }
-            });
+        const credentials = resolveCredentials(this.options, config);
+        applyCredentialsToConfig(config, credentials);
+
+        const capsList = Array.isArray(capabilities) ? capabilities : [capabilities];
+        applyCredentialsToCapabilities(capsList, credentials);
+
+        if (credentials.user && credentials.key) {
             console.log('[LambdaTest Service] Credentials injected into config and capabilities.');
         } else {
             console.error('[LambdaTest Service] Credentials not found! Please check service options or env vars.');

package/src/service.js

@@ -1,4 +1,16 @@
+const LOG_TAG = '[LambdaTest SDK]';
+const COLORS = {
+    reset: '\x1b[0m',
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m'
+};
 
+/**
+ * WebdriverIO service for LambdaTest: updates test status on the LambdaTest platform
+ * after each test (Mocha/Jasmine) or scenario (Cucumber).
+ */
 module.exports = class LambdaTestService {
     constructor(serviceOptions, capabilities, config) {
         this.options = serviceOptions || {};
@@ -10,44 +22,40 @@ module.exports = class LambdaTestService {
     }
 
     /**
-     * Triggered after each test (Mocha/Jasmine)
+     * WDIO lifecycle: after each test (Mocha/Jasmine). Handles v5/v6/v7 result shape differences.
      */
     async afterTest(test, context, result) {
-        // Handle WDIO v5/v6/v7 differences
         let passed = false;
-        let error = undefined;
+        let error;
         let title = 'Test';
 
-        // Check if result is the object { error, result, duration, passed, retries }
         if (result && typeof result.passed === 'boolean') {
             passed = result.passed;
             error = result.error;
-        } 
-        // Fallback for older/different versions where result might be the passed boolean or different structure
-        else if (test && typeof test.passed === 'boolean') {
+        } else if (test && typeof test.passed === 'boolean') {
             passed = test.passed;
             error = test.error;
         }
-        
         if (test && test.title) title = test.title;
 
-        await this.updateStatus(passed, error ? (error.message || error) : undefined, title);
+        const errorMessage = error ? (error.message || error) : undefined;
+        await this.updateStatus(passed, errorMessage, title);
     }
 
     /**
-     * Triggered after each scenario (Cucumber)
+     * WDIO lifecycle: after each scenario (Cucumber).
      */
     async afterScenario(uri, feature, scenario, result) {
         const isPassed = result.status === 'passed' || result === 'passed' || result.passed === true;
-        const errorMessage = result.error ? result.error : (isPassed ? undefined : 'Scenario Failed');
+        const errorMessage = getScenarioErrorMessage(result, isPassed);
         const title = scenario.name || 'Scenario';
         await this.updateStatus(isPassed, errorMessage, title);
     }
 
     /**
-     * Updates the test status on LambdaTest
-     * @param {boolean} passed 
-     * @param {string} errorMessage 
+     * Updates the test status on LambdaTest via browser hook.
+     * @param {boolean} passed
+     * @param {string|undefined} errorMessage
      * @param {string} testTitle
      */
     async updateStatus(passed, errorMessage, testTitle) {
@@ -55,43 +63,31 @@ module.exports = class LambdaTestService {
 
         const status = passed ? 'passed' : 'failed';
         const remark = errorMessage || (passed ? 'Test Passed' : 'Test Failed');
-
-        // ANSI Color Codes
-        const reset = "\x1b[0m";
-        const green = "\x1b[32m";
-        const red = "\x1b[31m";
-        const cyan = "\x1b[36m";
-        const gray = "\x1b[90m";
-
-        const color = passed ? green : red;
+        const color = passed ? COLORS.green : COLORS.red;
         const icon = passed ? '✔' : '✖';
-        
-        console.log(`\n${cyan}[LambdaTest SDK]${reset} ${gray}Updating Status...${reset}`);
-        console.log(`${cyan}[LambdaTest SDK]${reset} Test:   ${testTitle}`);
-        console.log(`${cyan}[LambdaTest SDK]${reset} Status: ${color}${status.toUpperCase()} ${icon}${reset}`);
+
+        console.log(`\n${COLORS.cyan}${LOG_TAG}${COLORS.reset} ${COLORS.gray}Updating Status...${COLORS.reset}`);
+        console.log(`${COLORS.cyan}${LOG_TAG}${COLORS.reset} Test:   ${testTitle}`);
+        console.log(`${COLORS.cyan}${LOG_TAG}${COLORS.reset} Status: ${color}${status.toUpperCase()} ${icon}${COLORS.reset}`);
         if (!passed) {
-            console.log(`${cyan}[LambdaTest SDK]${reset} Reason: ${red}${remark}${reset}`);
+            console.log(`${COLORS.cyan}${LOG_TAG}${COLORS.reset} Reason: ${COLORS.red}${remark}${COLORS.reset}`);
         }
-        console.log(''); // Empty line
+        console.log('');
 
         try {
-            // Using browser.execute to trigger the Lambda Hook
             const script = `lambda-hook: ${JSON.stringify({
                 action: 'setTestStatus',
-                arguments: {
-                    status: status,
-                    remark: remark
-                }
+                arguments: { status, remark }
             })}`;
-            
-            // Await the execution in case we are in async mode
             await browser.execute(script);
-            
-            // Add a small pause to ensure the hook is processed before session ends
             await browser.pause(1000);
-            
         } catch (e) {
-            console.error(`${red}[LambdaTest SDK] Failed to update test status via hook.${reset}`, e);
+            console.error(`${COLORS.red}${LOG_TAG} Failed to update test status via hook.${COLORS.reset}`, e);
         }
     }
 };
+
+function getScenarioErrorMessage(result, isPassed) {
+    if (result.error) return result.error;
+    return isPassed ? undefined : 'Scenario Failed';
+}