@wdio/mcp 3.5.1 → 3.6.0

package/lib/server.js

@@ -46,7 +46,7 @@ var package_default = {
     type: "git",
     url: "git://github.com/webdriverio/mcp.git"
   },
-  version: "3.5.0",
+  version: "3.5.1",
   description: "MCP server with WebdriverIO for browser and mobile app automation (iOS/Android via Appium)",
   main: "./lib/server.js",
   module: "./lib/server.js",
@@ -91,12 +91,14 @@ var package_default = {
     test: "vitest run"
   },
   dependencies: {
+    "@lambdatest/node-tunnel": "^4.0.11",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@toon-format/toon": "^2.1.0",
     "@wdio/protocols": "^9.27.0",
     "@xmldom/xmldom": "^0.9.10",
     "browserstack-local": "^1.5.12",
     "puppeteer-core": "^24.40.0",
+    saucelabs: "^9.0.2",
     sharp: "^0.34.5",
     webdriverio: "^9.27.0",
     xpath: "^0.0.34",
@@ -2427,6 +2429,134 @@ var browserstackLocalBinaryResource = {
   }
 };
 
+// src/resources/saucelabs-local.resource.ts
+function getLocalBinaryInfo2() {
+  const platform2 = process.platform;
+  const arch = process.arch;
+  if (platform2 === "darwin") {
+    return {
+      downloadUrl: "https://saucelabs.com/downloads/sc-4.9.2-osx.zip",
+      platform: "macOS",
+      arch: arch === "arm64" ? "Apple Silicon" : "Intel x64",
+      binaryName: "sc"
+    };
+  }
+  if (platform2 === "win32") {
+    return {
+      downloadUrl: "https://saucelabs.com/downloads/sc-4.9.2-win32.zip",
+      platform: "Windows",
+      arch: "x86/x64",
+      binaryName: "sc.exe"
+    };
+  }
+  return {
+    downloadUrl: "https://saucelabs.com/downloads/sc-4.9.2-linux.tar.gz",
+    platform: "Linux",
+    arch: arch === "arm64" ? "ARM64" : "x64",
+    binaryName: "sc"
+  };
+}
+var saucelabsLocalBinaryResource = {
+  name: "saucelabs-local-binary",
+  uri: "wdio://saucelabs/local-binary",
+  description: "Sauce Connect Proxy binary download URL and daemon setup instructions for the current platform. Only needed for tunnel: 'external' \u2014 when tunnel: true the SDK auto-manages Sauce Connect for you.",
+  handler: async () => {
+    const info = getLocalBinaryInfo2();
+    const username = process.env.SAUCE_USERNAME ?? "<SAUCE_USERNAME>";
+    const accessKey = process.env.SAUCE_ACCESS_KEY ?? "<SAUCE_ACCESS_KEY>";
+    const region = process.env.SAUCE_REGION ?? "eu-central-1";
+    const content = {
+      requirement: "ONLY needed for tunnel: 'external'. Use tunnel: true instead \u2014 the SDK starts and stops Sauce Connect automatically. With tunnel: 'external', you MUST start the daemon manually BEFORE calling start_session, and set tunnelName to match the running tunnel.",
+      platform: info.platform,
+      arch: info.arch,
+      downloadUrl: info.downloadUrl,
+      ...info.note ? { note: info.note } : {},
+      setup: [
+        `1. Download: curl -O ${info.downloadUrl}`,
+        `2. Unzip: ${info.downloadUrl.endsWith(".tar.gz") ? `tar -xzf ${info.downloadUrl.split("/").pop()}` : `unzip ${info.downloadUrl.split("/").pop()}`}`,
+        `3. Make executable (macOS/Linux): chmod +x ${info.binaryName}`,
+        `4. Start daemon: ./${info.binaryName} -u ${username} -k ${accessKey} --region ${region}`
+      ],
+      commands: {
+        start: `./${info.binaryName} -u ${username} -k ${accessKey} --region ${region}`,
+        stop: `./${info.binaryName} --stop`,
+        status: `./${info.binaryName} --status`
+      },
+      afterDaemonIsRunning: "Call start_session with tunnel: 'external' and tunnelName matching this daemon to route traffic through it."
+    };
+    return {
+      contents: [{
+        uri: "wdio://saucelabs/local-binary",
+        mimeType: "application/json",
+        text: JSON.stringify(content, null, 2)
+      }]
+    };
+  }
+};
+
+// src/resources/testmu-local.resource.ts
+function getLocalBinaryInfo3() {
+  const platform2 = process.platform;
+  const arch = process.arch;
+  if (platform2 === "darwin") {
+    return {
+      downloadUrl: "https://downloads.lambdatest.com/tunnel/v4/darwin/64bit/LT_Darwin.zip",
+      platform: "macOS",
+      arch: arch === "arm64" ? "Apple Silicon (via Rosetta 2)" : "Intel x64",
+      binaryName: "LT"
+    };
+  }
+  if (platform2 === "win32") {
+    return {
+      downloadUrl: "https://downloads.lambdatest.com/tunnel/v4/win/64bit/LT_Windows.zip",
+      platform: "Windows",
+      arch: "x86/x64",
+      binaryName: "LT.exe"
+    };
+  }
+  return {
+    downloadUrl: "https://downloads.lambdatest.com/tunnel/v4/linux/64bit/LT_Linux.zip",
+    platform: "Linux",
+    arch: arch === "arm64" ? "ARM64" : "x64",
+    binaryName: "LT"
+  };
+}
+var testmuLocalBinaryResource = {
+  name: "testmu-local-binary",
+  uri: "wdio://testmu/local-binary",
+  description: "TestMu Tunnel binary download URL and daemon setup instructions for the current platform. MUST be read and followed before using tunnel: true in start_session with provider: testmu.",
+  handler: async () => {
+    const info = getLocalBinaryInfo3();
+    const username = process.env.TESTMU_USERNAME ?? "<TESTMU_USERNAME>";
+    const accessKey = process.env.TESTMU_ACCESS_KEY ?? "<TESTMU_ACCESS_KEY>";
+    const content = {
+      requirement: "MUST start the TestMu Tunnel daemon BEFORE calling start_session with tunnel: true. Without it, all navigation to local/internal URLs will fail.",
+      platform: info.platform,
+      arch: info.arch,
+      downloadUrl: info.downloadUrl,
+      setup: [
+        `1. Download: curl -O ${info.downloadUrl}`,
+        `2. Unzip: unzip ${info.downloadUrl.split("/").pop()}`,
+        `3. Make executable (macOS/Linux): chmod +x ${info.binaryName}`,
+        `4. Start daemon: ./${info.binaryName} --user ${username} --key ${accessKey}`
+      ],
+      commands: {
+        start: `./${info.binaryName} --user ${username} --key ${accessKey}`,
+        stop: `./${info.binaryName} --user ${username} --key ${accessKey} --stop`,
+        status: `./${info.binaryName} --status`
+      },
+      afterDaemonIsRunning: "Call start_session with tunnel: true and provider: testmu to route TestMu traffic through the tunnel."
+    };
+    return {
+      contents: [{
+        uri: "wdio://testmu/local-binary",
+        mimeType: "application/json",
+        text: JSON.stringify(content, null, 2)
+      }]
+    };
+  }
+};
+
 // src/resources/sessions.resource.ts
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 
@@ -2453,6 +2583,8 @@ function generateStep(step, history) {
     case "start_session": {
       const platform2 = p.platform;
       const isBrowserStack = "bstack:options" in history.capabilities;
+      const isSauceLabs = "sauce:options" in history.capabilities;
+      const isLambdaTest = "lt:options" in history.capabilities;
       const capJson = indentJson(history.capabilities).split("\n").map((line, i) => i > 0 ? `  ${line}` : line).join("\n");
       if (isBrowserStack) {
         const nav = platform2 === "browser" && p.navigationUrl ? `
@@ -2469,6 +2601,39 @@ await browser.url('${escapeStr(p.navigationUrl)}');` : "";
           `});${nav}`
         ].join("\n");
       }
+      if (isSauceLabs) {
+        const region = history.capabilities["sauce:options"]?.region ?? "eu-central-1";
+        const nav = platform2 === "browser" && p.navigationUrl ? `
+await browser.url('${escapeStr(p.navigationUrl)}');` : "";
+        return [
+          "const browser = await remote({",
+          "  protocol: 'https',",
+          `  hostname: 'ondemand.${region}.saucelabs.com',`,
+          "  port: 443,",
+          "  path: '/wd/hub',",
+          "  user: process.env.SAUCE_USERNAME,",
+          "  key: process.env.SAUCE_ACCESS_KEY,",
+          `  capabilities: ${capJson}`,
+          `});${nav}`
+        ].join("\n");
+      }
+      if (isLambdaTest) {
+        const isBrowser = platform2 === "browser";
+        const hostname = isBrowser ? "hub.lambdatest.com" : "mobile-hub.lambdatest.com";
+        const nav = platform2 === "browser" && p.navigationUrl ? `
+await browser.url('${escapeStr(p.navigationUrl)}');` : "";
+        return [
+          "const browser = await remote({",
+          "  protocol: 'https',",
+          `  hostname: '${hostname}',`,
+          "  port: 443,",
+          "  path: '/wd/hub',",
+          "  user: process.env.TESTMU_USERNAME,",
+          "  key: process.env.TESTMU_ACCESS_KEY,",
+          `  capabilities: ${capJson}`,
+          `});${nav}`
+        ].join("\n");
+      }
       if (platform2 === "browser") {
         const nav = p.navigationUrl ? `
 await browser.url('${escapeStr(p.navigationUrl)}');` : "";
@@ -2531,8 +2696,12 @@ function bsStatusUpdateLines(sessionType) {
 }
 function generateCode(history) {
   const bstackOptions = history.capabilities["bstack:options"];
+  const sauceOptions = history.capabilities["sauce:options"];
+  const ltOptions = history.capabilities["lt:options"];
   const isBrowserStack = bstackOptions !== void 0;
-  const usesBrowserstackLocal = bstackOptions?.local === true;
+  const isSauceLabs = sauceOptions !== void 0;
+  const isLambdaTest = ltOptions !== void 0;
+  const usesLocalTunnel = isBrowserStack ? bstackOptions?.local === true : isSauceLabs ? sauceOptions?.tunnelName !== void 0 : ltOptions?.tunnel === true;
   const steps = history.steps.map((step) => generateStep(step, history)).join("\n").split("\n").map((line) => `  ${line}`).join("\n");
   if (isBrowserStack) {
     const bsSteps = steps.replace(/const browser = await remote\(/g, "browser = await remote(");
@@ -2543,7 +2712,7 @@ function generateCode(history) {
 ${statusUpdate}
     await browser.deleteSession();
   }`;
-    if (usesBrowserstackLocal) {
+    if (usesLocalTunnel) {
       const tunnelSetup = [
         "",
         "const tunnel = new BrowserstackTunnel();",
@@ -2579,6 +2748,119 @@ ${statusUpdate}
       "}"
     ].join("\n");
   }
+  if (isSauceLabs) {
+    const slSteps = steps.replace(/const browser = await remote\(/g, "browser = await remote(");
+    const preamble = "let browser;\nlet slStatus = 'passed';\nlet slReason;";
+    const catchBlock = "} catch (e) {\n  slStatus = 'failed';\n  slReason = String(e);\n  throw e;";
+    const slRegion = sauceOptions?.region ?? "eu-central-1";
+    const statusUpdate = [
+      "    const slAuth = Buffer.from(`${process.env.SAUCE_USERNAME}:${process.env.SAUCE_ACCESS_KEY}`).toString('base64');",
+      `    await fetch(\`https://api.${slRegion}.saucelabs.com/rest/v1/\${process.env.SAUCE_USERNAME}/jobs/\` + browser.sessionId, {`,
+      "      method: 'PUT',",
+      "      headers: { Authorization: 'Basic ' + slAuth, 'Content-Type': 'application/json' },",
+      "      body: JSON.stringify({ passed: slStatus === 'passed' })",
+      "    });"
+    ].join("\n");
+    const finallyLines = [
+      "  if (browser) {",
+      statusUpdate,
+      "    await browser.deleteSession();",
+      "  }"
+    ];
+    if (usesLocalTunnel) {
+      const tunnelSetup = [
+        "",
+        "import SauceLabs from 'saucelabs';",
+        "",
+        "const sl = new SauceLabs({",
+        "  user: process.env.SAUCE_USERNAME,",
+        "  key: process.env.SAUCE_ACCESS_KEY,",
+        `  region: '${slRegion}',`,
+        "});",
+        "const sc = await sl.startSauceConnect({ tunnelName: 'wdio-mcp-tunnel' });",
+        "const stopTunnel = () => sc.close();",
+        ""
+      ].join("\n");
+      return [
+        "import { remote } from 'webdriverio';",
+        tunnelSetup,
+        preamble,
+        "try {",
+        slSteps,
+        catchBlock,
+        "} finally {",
+        ...finallyLines,
+        "  await stopTunnel();",
+        "}"
+      ].join("\n");
+    }
+    return [
+      "import { remote } from 'webdriverio';",
+      "",
+      preamble,
+      "try {",
+      slSteps,
+      catchBlock,
+      "} finally {",
+      ...finallyLines,
+      "}"
+    ].join("\n");
+  }
+  if (isLambdaTest) {
+    const ltSteps = steps.replace(/const browser = await remote\(/g, "browser = await remote(");
+    const preamble = "let browser;\nlet ltStatus = 'passed';";
+    const catchBlock = "} catch (e) {\n  ltStatus = 'failed';\n  throw e;";
+    const isMobile = history.type !== "browser";
+    const statusUpdate = isMobile ? "    await browser.execute('lambda-status=' + ltStatus);" : [
+      "    const ltAuth = Buffer.from(`${process.env.TESTMU_USERNAME}:${process.env.TESTMU_ACCESS_KEY}`).toString('base64');",
+      "    await fetch('https://api.lambdatest.com/automation/api/v1/sessions/' + browser.sessionId, {",
+      "      method: 'PATCH',",
+      "      headers: { Authorization: 'Basic ' + ltAuth, 'Content-Type': 'application/json' },",
+      "      body: JSON.stringify({ status_ind: ltStatus })",
+      "    });"
+    ].join("\n");
+    const finallyLines = [
+      "  if (browser) {",
+      statusUpdate,
+      "    await browser.deleteSession();",
+      "  }"
+    ];
+    if (usesLocalTunnel) {
+      const tunnelName = ltOptions?.tunnelName ?? "wdio-mcp-tunnel";
+      const tunnelSetup = [
+        "",
+        "import LambdaTunnel from '@lambdatest/node-tunnel';",
+        "",
+        "const tunnel = new LambdaTunnel();",
+        `await tunnel.start({ user: process.env.TESTMU_USERNAME, key: process.env.TESTMU_ACCESS_KEY, tunnelName: '${escapeStr(tunnelName)}' });`,
+        "const stopTunnel = () => tunnel.stop();",
+        ""
+      ].join("\n");
+      return [
+        "import { remote } from 'webdriverio';",
+        tunnelSetup,
+        preamble,
+        "try {",
+        ltSteps,
+        catchBlock,
+        "} finally {",
+        ...finallyLines,
+        "  await stopTunnel();",
+        "}"
+      ].join("\n");
+    }
+    return [
+      "import { remote } from 'webdriverio';",
+      "",
+      preamble,
+      "try {",
+      ltSteps,
+      catchBlock,
+      "} finally {",
+      ...finallyLines,
+      "}"
+    ].join("\n");
+  }
   return `import { remote } from 'webdriverio';
 
 try {
@@ -3276,7 +3558,7 @@ import { z as z14 } from "zod";
 // src/session/lifecycle.ts
 init_state();
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } from "path";
+import { join as join5 } from "path";
 
 // src/providers/local-browser.provider.ts
 var LocalBrowserProvider = class {
@@ -3531,6 +3813,13 @@ import { promisify } from "util";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join2 } from "path";
 import { Local as BrowserstackTunnel } from "browserstack-local";
+
+// src/utils/auth.ts
+function basicAuth(user, key) {
+  return Buffer.from(`${user}:${key}`).toString("base64");
+}
+
+// src/providers/cloud/browserstack.provider.ts
 var BrowserStackProvider = class {
   name = "browserstack";
   getConnectionConfig(options) {
@@ -3548,7 +3837,7 @@ var BrowserStackProvider = class {
   buildCapabilities(options) {
     const platform2 = options.platform;
     const userCapabilities = options.capabilities ?? {};
-    const browserstackLocal = options.browserstackLocal;
+    const browserstackLocal = options.tunnel ?? options.browserstackLocal;
     if (platform2 === "browser") {
       const bstackOptions2 = {
         browserVersion: options.browserVersion ?? "latest"
@@ -3561,9 +3850,9 @@ var BrowserStackProvider = class {
       if (reporting2?.build) bstackOptions2.buildName = reporting2.build;
       if (reporting2?.session) bstackOptions2.sessionName = reporting2.session;
       return {
+        ...userCapabilities,
         browserName: options.browser ?? "chrome",
-        "bstack:options": bstackOptions2,
-        ...userCapabilities
+        "bstack:options": bstackOptions2
       };
     }
     const bstackOptions = {
@@ -3581,14 +3870,14 @@ var BrowserStackProvider = class {
     const autoAcceptAlerts = options.autoAcceptAlerts;
     const autoDismissAlerts = options.autoDismissAlerts;
     return {
+      ...userCapabilities,
       platformName: platform2,
       "appium:app": options.app,
       "appium:autoGrantPermissions": options.autoGrantPermissions ?? true,
       "appium:autoAcceptAlerts": autoDismissAlerts ? void 0 : autoAcceptAlerts ?? true,
       "appium:autoDismissAlerts": autoDismissAlerts,
       "appium:newCommandTimeout": options.newCommandTimeout ?? 300,
-      "bstack:options": bstackOptions,
-      ...userCapabilities
+      "bstack:options": bstackOptions
     };
   }
   getSessionType(options) {
@@ -3626,7 +3915,7 @@ var BrowserStackProvider = class {
     const key = process.env.BROWSERSTACK_ACCESS_KEY;
     if (!user || !key) return;
     const baseUrl = sessionType === "browser" ? "https://api.browserstack.com/automate/sessions" : "https://api-cloud.browserstack.com/app-automate/sessions";
-    const auth = Buffer.from(`${user}:${key}`).toString("base64");
+    const auth = basicAuth(user, key);
     const body = { status: result.status, ...result.reason ? { reason: result.reason } : {} };
     await fetch(`${baseUrl}/${sessionId}.json`, {
       method: "PUT",
@@ -3637,11 +3926,305 @@ var BrowserStackProvider = class {
 };
 var browserStackProvider = new BrowserStackProvider();
 
+// src/providers/cloud/saucelabs.provider.ts
+import SauceLabs from "saucelabs";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join3 } from "path";
+var SauceLabsProvider = class {
+  name = "saucelabs";
+  resolveRegion(options) {
+    return options.region ?? "eu-central-1";
+  }
+  getConnectionConfig(options) {
+    const region = this.resolveRegion(options);
+    return {
+      protocol: "https",
+      hostname: `ondemand.${region}.saucelabs.com`,
+      port: 443,
+      path: "/wd/hub",
+      user: process.env.SAUCE_USERNAME,
+      key: process.env.SAUCE_ACCESS_KEY
+    };
+  }
+  buildCapabilities(options) {
+    const platform2 = options.platform;
+    const region = this.resolveRegion(options);
+    const userCapabilities = options.capabilities ?? {};
+    const saucelabsLocal = options.tunnel ?? options.saucelabsLocal;
+    const reporting = options.reporting;
+    const sauceOptions = { region };
+    if (reporting?.build) sauceOptions.build = reporting.build;
+    if (reporting?.session) sauceOptions.name = reporting.session;
+    else if (reporting?.project) sauceOptions.name = reporting.project;
+    if (saucelabsLocal) {
+      sauceOptions.tunnelName = options.tunnelName;
+    }
+    if (platform2 === "browser") {
+      return {
+        ...userCapabilities,
+        browserName: options.browser ?? "chrome",
+        browserVersion: options.browserVersion ?? "latest",
+        platformName: options.os ? [options.os, options.osVersion].filter(Boolean).join(" ") : "Linux",
+        "sauce:options": sauceOptions
+      };
+    }
+    const mobileBrowser = options.browser;
+    if (mobileBrowser) {
+      if (options.deviceOrientation) sauceOptions.deviceOrientation = options.deviceOrientation;
+      const caps = {
+        platformName: platform2,
+        browserName: mobileBrowser,
+        "appium:deviceName": options.deviceName,
+        "appium:platformVersion": options.platformVersion,
+        "appium:automationName": options.automationName ?? (platform2 === "ios" ? "XCUITest" : "UiAutomator2"),
+        "appium:newCommandTimeout": options.newCommandTimeout ?? 300,
+        "sauce:options": sauceOptions
+      };
+      return { ...userCapabilities, ...caps };
+    }
+    sauceOptions.appiumVersion = "latest";
+    const autoAcceptAlerts = options.autoAcceptAlerts;
+    const autoDismissAlerts = options.autoDismissAlerts;
+    return {
+      ...userCapabilities,
+      platformName: platform2,
+      "appium:app": options.app,
+      "appium:deviceName": options.deviceName,
+      "appium:platformVersion": options.platformVersion,
+      "appium:automationName": options.automationName ?? (platform2 === "ios" ? "XCUITest" : "UiAutomator2"),
+      "appium:autoGrantPermissions": options.autoGrantPermissions ?? true,
+      "appium:autoAcceptAlerts": autoDismissAlerts ? void 0 : autoAcceptAlerts ?? true,
+      "appium:autoDismissAlerts": autoDismissAlerts,
+      "appium:newCommandTimeout": options.newCommandTimeout ?? 300,
+      "sauce:options": sauceOptions
+    };
+  }
+  getSessionType(options) {
+    const platform2 = options.platform;
+    if (platform2 === "browser") return "browser";
+    return platform2;
+  }
+  shouldAutoDetach(_options) {
+    return false;
+  }
+  async startTunnel(options) {
+    const region = this.resolveRegion(options);
+    const tunnelName = options.tunnelName ?? `wdio-mcp-${Date.now()}`;
+    const logFile = join3(tmpdir3(), "sauce-connect.log");
+    console.error(`[SauceLabs] Starting tunnel "${tunnelName}" (region: ${region})`);
+    try {
+      const api = new SauceLabs({ user: process.env.SAUCE_USERNAME ?? "", key: process.env.SAUCE_ACCESS_KEY ?? "", region });
+      return api.startSauceConnect({
+        tunnelName,
+        logFile,
+        logger: (msg) => console.error(`[SauceConnect] ${msg}`)
+      });
+    } catch (e) {
+      const msg = (e !== null && typeof e === "object" ? e.message : void 0) ?? String(e);
+      if (msg.includes("already running") || msg.includes("another instance")) {
+        console.error("[SauceLabs] Tunnel already running \u2014 reusing existing tunnel");
+        return null;
+      }
+      throw e;
+    }
+  }
+  async onSessionClose(sessionId, _sessionType, result, _tunnelHandle, _browser, region) {
+    const effectiveRegion = region ?? "eu-central-1";
+    const user = process.env.SAUCE_USERNAME;
+    const key = process.env.SAUCE_ACCESS_KEY;
+    if (user && key) {
+      try {
+        const auth = basicAuth(user, key);
+        const body = { passed: result.status === "passed" };
+        const apiUrl = `https://api.${effectiveRegion}.saucelabs.com/rest/v1/${user}/jobs/${sessionId}`;
+        console.error(`[SauceLabs] Setting job status for ${sessionId}: ${result.status}`);
+        await fetch(apiUrl, {
+          method: "PUT",
+          headers: {
+            Authorization: `Basic ${auth}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(body)
+        });
+        console.error("[SauceLabs] Job result set successfully via REST API");
+      } catch (e) {
+        console.error("[SauceLabs] Failed to set job result via REST API:", e);
+      }
+    }
+  }
+  async stopTunnel(tunnelHandle) {
+    if (tunnelHandle) {
+      const sc = tunnelHandle;
+      await sc.close();
+    }
+  }
+};
+var sauceLabsProvider = new SauceLabsProvider();
+
+// src/providers/cloud/testmu.provider.ts
+import LambdaTunnel from "@lambdatest/node-tunnel";
+import { tmpdir as tmpdir4 } from "os";
+import { join as join4 } from "path";
+var TestMuProvider = class {
+  name = "testmu";
+  getConnectionConfig(options) {
+    const platform2 = options.platform;
+    const isBrowser = platform2 === "browser";
+    return {
+      protocol: "https",
+      hostname: isBrowser ? "hub.lambdatest.com" : "mobile-hub.lambdatest.com",
+      port: 443,
+      path: "/wd/hub",
+      user: process.env.TESTMU_USERNAME,
+      key: process.env.TESTMU_ACCESS_KEY
+    };
+  }
+  buildCapabilities(options) {
+    const platform2 = options.platform;
+    const userCapabilities = options.capabilities ?? {};
+    const tunnel = options.tunnel ?? options.testmuLocal;
+    const reporting = options.reporting;
+    const ltOptions = { w3c: true };
+    if (reporting?.project) ltOptions.project = reporting.project;
+    if (reporting?.build) ltOptions.build = reporting.build;
+    if (reporting?.session) ltOptions.name = reporting.session;
+    else if (reporting?.project) ltOptions.name = reporting.project;
+    if (tunnel) {
+      ltOptions.tunnel = true;
+      if (options.tunnelName) ltOptions.tunnelName = options.tunnelName;
+    }
+    if (platform2 === "browser") {
+      return {
+        ...userCapabilities,
+        browserName: options.browser ?? "chrome",
+        browserVersion: options.browserVersion ?? "latest",
+        platformName: options.os ? [options.os, options.osVersion].filter(Boolean).join(" ") : "Linux",
+        "lt:options": ltOptions
+      };
+    }
+    const mobileBrowser = options.browser;
+    if (mobileBrowser) {
+      ltOptions.isRealMobile = false;
+      if (options.deviceOrientation) ltOptions.deviceOrientation = options.deviceOrientation;
+      const caps2 = {
+        platformName: platform2,
+        browserName: mobileBrowser,
+        "appium:deviceName": options.deviceName,
+        "appium:platformVersion": options.platformVersion,
+        "appium:automationName": options.automationName ?? (platform2 === "ios" ? "XCUITest" : "UiAutomator2"),
+        "appium:newCommandTimeout": options.newCommandTimeout ?? 300,
+        "lt:options": ltOptions
+      };
+      return { ...userCapabilities, ...caps2 };
+    }
+    ltOptions.appiumVersion = "latest";
+    ltOptions.isRealMobile = true;
+    const autoAcceptAlerts = options.autoAcceptAlerts;
+    const autoDismissAlerts = options.autoDismissAlerts;
+    const caps = {
+      platformName: platform2,
+      "appium:app": options.app,
+      "appium:deviceName": options.deviceName,
+      "appium:platformVersion": options.platformVersion,
+      "appium:automationName": options.automationName ?? (platform2 === "ios" ? "XCUITest" : "UiAutomator2"),
+      "appium:autoGrantPermissions": options.autoGrantPermissions ?? true,
+      "appium:autoAcceptAlerts": autoDismissAlerts ? void 0 : autoAcceptAlerts ?? true,
+      "appium:autoDismissAlerts": autoDismissAlerts,
+      "appium:newCommandTimeout": options.newCommandTimeout ?? 300,
+      "lt:options": ltOptions
+    };
+    return { ...userCapabilities, ...caps };
+  }
+  getSessionType(options) {
+    const platform2 = options.platform;
+    if (platform2 === "browser") return "browser";
+    return platform2;
+  }
+  shouldAutoDetach(_options) {
+    return false;
+  }
+  async startTunnel(options) {
+    const tunnelName = options.tunnelName ?? `wdio-mcp-testmu-${Date.now()}`;
+    const logFile = join4(tmpdir4(), "testmu-tunnel.log");
+    console.error(`[TestMu] Starting tunnel "${tunnelName}"`);
+    try {
+      const tunnel = new LambdaTunnel();
+      await tunnel.start({
+        user: process.env.TESTMU_USERNAME ?? "",
+        key: process.env.TESTMU_ACCESS_KEY ?? "",
+        tunnelName,
+        logFile
+      });
+      console.error(`[TestMu] Tunnel started: "${tunnelName}"`);
+      return tunnel;
+    } catch (e) {
+      const msg = (e !== null && typeof e === "object" ? e.message : void 0) ?? String(e);
+      if (msg.includes("already running") || msg.includes("another tunnel") || msg.includes("already in use")) {
+        console.error("[TestMu] Tunnel already running \u2014 reusing existing tunnel");
+        return null;
+      }
+      throw e;
+    }
+  }
+  async onSessionClose(sessionId, sessionType, result, _tunnelHandle, browser, _region) {
+    const user = process.env.TESTMU_USERNAME;
+    const key = process.env.TESTMU_ACCESS_KEY;
+    if (!user || !key) return;
+    const status = result.status === "passed" ? "passed" : "failed";
+    if (sessionType !== "browser") {
+      try {
+        console.error(`[TestMu] Setting mobile session status for ${sessionId}: ${status}`);
+        await browser?.execute("lambda-status=" + status);
+        console.error("[TestMu] Mobile session status set successfully via execute");
+      } catch (e) {
+        console.error("[TestMu] Failed to set mobile session status via execute:", e);
+      }
+      return;
+    }
+    try {
+      const auth = basicAuth(user, key);
+      const body = { status_ind: status };
+      const apiUrl = `https://api.lambdatest.com/automation/api/v1/sessions/${sessionId}`;
+      console.error(`[TestMu] Setting session status for ${sessionId}: ${body.status_ind}`);
+      const res = await fetch(apiUrl, {
+        method: "PATCH",
+        headers: {
+          Authorization: `Basic ${auth}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+      if (res.ok) {
+        console.error("[TestMu] Session status set successfully via REST API");
+      } else {
+        const resBody = await res.text();
+        console.error(`[TestMu] Failed to set session status: HTTP ${res.status} \u2014 ${resBody}`);
+      }
+    } catch (e) {
+      console.error("[TestMu] Failed to set session status via REST API:", e);
+    }
+  }
+  async stopTunnel(tunnelHandle) {
+    if (tunnelHandle) {
+      const tunnel = tunnelHandle;
+      await tunnel.stop();
+    }
+  }
+};
+var testMuProvider = new TestMuProvider();
+
 // src/providers/registry.ts
-function getProvider(providerName, platform2) {
-  if (providerName === "browserstack") return browserStackProvider;
+var providers = /* @__PURE__ */ new Map([
+  ["browserstack", browserStackProvider],
+  ["saucelabs", sauceLabsProvider],
+  ["testmu", testMuProvider]
+]);
+function getDefaultProvider(platform2) {
   return platform2 === "browser" ? localBrowserProvider : localAppiumProvider;
 }
+function getProvider(providerName, platform2) {
+  return providers.get(providerName) ?? getDefaultProvider(platform2);
+}
 
 // src/trace/zip-writer.ts
 import yazl from "yazl";
@@ -3671,10 +4254,10 @@ async function finalizeTrace(sessionId, browser) {
   if (!traceSession) return;
   try {
     await traceSession.screenshotChain;
-    const traceDir = join3(process.cwd(), ".trace");
+    const traceDir = join5(process.cwd(), ".trace");
     mkdirSync2(traceDir, { recursive: true });
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const outPath = join3(traceDir, `${timestamp}-${sessionId.slice(0, 8)}.zip`);
+    const outPath = join5(traceDir, `${timestamp}-${sessionId.slice(0, 8)}.zip`);
     const zipBuffer = await buildTraceZip(traceSession);
     writeFileSync2(outPath, zipBuffer);
     console.error(`[TRACE] Saved to ${outPath}`);
@@ -3726,11 +4309,16 @@ function registerSession(sessionId, browser, metadata, historyEntry) {
         if (oldMetadata?.provider) {
           const oldHistory = state2.sessionHistory.get(oldSessionId);
           const provider = getProvider(oldMetadata.provider, oldMetadata.type);
-          await provider.onSessionClose?.(oldSessionId, oldMetadata.type, getSessionResult(oldHistory), oldMetadata.tunnelHandle).catch(() => {
+          await provider.onSessionClose?.(oldSessionId, oldMetadata.type, getSessionResult(oldHistory), oldMetadata.tunnelHandle, oldBrowser, oldMetadata.region).catch(() => {
           });
         }
         await oldBrowser.deleteSession().catch(() => {
         });
+        if (oldMetadata?.provider && oldMetadata?.tunnelHandle) {
+          const provider = getProvider(oldMetadata.provider, oldMetadata.type);
+          await provider.stopTunnel?.(oldMetadata.tunnelHandle).catch(() => {
+          });
+        }
       })();
       state2.browsers.delete(oldSessionId);
       state2.sessionMetadata.delete(oldSessionId);
@@ -3753,12 +4341,20 @@ async function closeSession(sessionId, detach, isAttached, force) {
     if (metadata?.provider) {
       try {
         const provider = getProvider(metadata.provider, metadata.type);
-        await provider.onSessionClose?.(sessionId, metadata.type, getSessionResult(history), metadata.tunnelHandle);
+        await provider.onSessionClose?.(sessionId, metadata.type, getSessionResult(history), metadata.tunnelHandle, browser, metadata.region);
       } catch (e) {
         console.error("[WARN] Failed to run provider onSessionClose:", e);
       }
     }
     await browser.deleteSession();
+    if (metadata?.provider && metadata?.tunnelHandle) {
+      try {
+        const provider = getProvider(metadata.provider, metadata.type);
+        await provider.stopTunnel?.(metadata.tunnelHandle);
+      } catch (e) {
+        console.error("[WARN] Failed to stop tunnel:", e);
+      }
+    }
   }
   state2.browsers.delete(sessionId);
   state2.sessionMetadata.delete(sessionId);
@@ -3776,23 +4372,23 @@ var startSessionToolDefinition = {
   description: 'Starts a browser or mobile automation session. Only one active session at a time \u2014 starting a new one closes the existing session first. Use platform "browser" with a browser name, or "ios"/"android" with deviceName. Set attach: true to connect to a running Chrome via CDP instead of launching a new browser.',
   annotations: { title: "Start Session", destructiveHint: false },
   inputSchema: {
-    provider: z14.enum(["local", "browserstack"]).optional().default("local").describe("Session provider (default: local)"),
+    provider: z14.enum(["local", "browserstack", "saucelabs", "testmu"]).optional().default("local").describe("Session provider (default: local)"),
     platform: platformEnum.describe("Session platform type"),
     browser: browserEnum.optional().describe("Browser to launch (required for browser platform)"),
-    browserVersion: z14.string().optional().describe("Browser version (BrowserStack only, default: latest)"),
-    os: z14.string().optional().describe('Operating system (BrowserStack browser only, e.g. "Windows", "OS X")'),
-    osVersion: z14.string().optional().describe('OS version (BrowserStack browser only, e.g. "11", "Sequoia")'),
-    app: z14.string().optional().describe("BrowserStack app URL (bs://...) or custom_id for mobile sessions"),
+    browserVersion: z14.string().optional().describe("Browser version (cloud providers only, default: latest)"),
+    os: z14.string().optional().describe('Operating system for cloud provider browser sessions (e.g. "Windows", "Mac", "macOS", "Linux"). BrowserStack: sets bstack:options.os separately. TestMu/Sauce Labs: combined with osVersion into W3C platformName. Browser platform only.'),
+    osVersion: z14.string().optional().describe('OS version for cloud provider browser sessions (e.g. "11", "15", "Monterey"). BrowserStack: sets bstack:options.osVersion separately. TestMu/Sauce Labs: combined with os into W3C platformName. Browser platform only.'),
+    app: z14.string().optional().describe("App URL (bs://... for BrowserStack, storage:filename= for Sauce Labs, lt://... for TestMu mobile sessions)"),
     reporting: z14.object({
       project: z14.string().optional(),
       build: z14.string().optional(),
       session: z14.string().optional()
-    }).optional().describe("BrowserStack reporting labels (project, build, session)"),
+    }).optional().describe("Cloud provider reporting labels (project, build, session)"),
     headless: coerceBoolean.optional().default(true).describe("Run browser in headless mode (default: true)"),
     windowWidth: z14.number().min(400).max(3840).optional().default(1920).describe("Browser window width"),
     windowHeight: z14.number().min(400).max(2160).optional().default(1080).describe("Browser window height"),
     deviceName: z14.string().optional().describe("Mobile device/emulator/simulator name (required for ios/android)"),
-    platformVersion: z14.string().optional().describe('OS version (e.g., "17.0", "14")'),
+    platformVersion: z14.string().optional().describe('OS version for mobile sessions (e.g., "17.0", "14"). Mobile (ios/android) only.'),
     appPath: z14.string().optional().describe("Path to app file (.app/.apk/.ipa)"),
     automationName: automationEnum.optional().describe("Automation driver"),
     autoGrantPermissions: coerceBoolean.optional().describe("Auto-grant app permissions (default: true)"),
@@ -3815,7 +4411,12 @@ var startSessionToolDefinition = {
       path: z14.string().optional(),
       protocol: z14.string().optional()
     }).optional().describe("Appium server connection (local provider only)"),
-    browserstackLocal: z14.union([coerceBoolean, z14.literal("external")]).optional().default(false).describe('Enable BrowserStack Local tunnel routing (BrowserStack only, default: false). true = auto-start tunnel before session and stop on close. "external" = tunnel already running externally, set local: true in capabilities only.'),
+    region: z14.enum(["us-west-1", "eu-central-1", "apac-southeast-1"]).optional().default("eu-central-1").describe('Sauce Labs region (default: eu-central-1). Only used with provider: "saucelabs".'),
+    tunnel: z14.union([z14.literal("external"), coerceBoolean]).optional().default(false).describe('Enable local tunnel routing (cloud providers only, default: false). true = auto-start tunnel before session and stop on close. "external" = tunnel already running externally.'),
+    tunnelName: z14.string().optional().describe('Tunnel identifier name. With tunnel: "external" this must match the running tunnel. With tunnel: true a unique name is auto-generated if not provided.'),
+    browserstackLocal: z14.union([z14.literal("external"), coerceBoolean]).optional().describe('Deprecated: use "tunnel" instead. Enable BrowserStack Local tunnel routing.'),
+    saucelabsLocal: z14.union([z14.literal("external"), coerceBoolean]).optional().describe('Deprecated: use "tunnel" instead. Enable Sauce Connect tunnel routing.'),
+    testmuLocal: z14.union([z14.literal("external"), coerceBoolean]).optional().describe('Deprecated: use "tunnel" instead. Enable TestMu Tunnel routing.'),
     navigationUrl: z14.string().optional().describe("URL to navigate to after starting"),
     capabilities: z14.record(z14.string(), z14.unknown()).optional().describe("Additional capabilities to merge")
   }
@@ -3894,15 +4495,19 @@ async function startBrowserSession(args) {
   const effectiveHeadless = headless && headlessSupported;
   const provider = getProvider(args.provider ?? "local", "browser");
   const connectionConfig = provider.getConnectionConfig(args);
+  const effectiveTunnel = args.tunnel ?? args.browserstackLocal ?? args.saucelabsLocal ?? args.testmuLocal ?? false;
+  const tunnelEnabled = effectiveTunnel === true;
+  const tunnelName = tunnelEnabled && !args.tunnelName ? `wdio-mcp-${Date.now()}` : args.tunnelName;
   const mergedCapabilities = provider.buildCapabilities({
     ...args,
     browser,
     headless,
     windowWidth,
     windowHeight,
-    capabilities: userCapabilities
+    capabilities: userCapabilities,
+    tunnelName
   });
-  const tunnelHandle = args.browserstackLocal === true ? await provider.startTunnel?.(args) : void 0;
+  const tunnelHandle = tunnelEnabled ? await provider.startTunnel?.({ ...args, tunnelName }) : void 0;
   const wdioBrowser = await remote({ ...connectionConfig, capabilities: mergedCapabilities });
   const { sessionId } = wdioBrowser;
   const sessionMetadata = {
@@ -3910,6 +4515,8 @@ async function startBrowserSession(args) {
     capabilities: mergedCapabilities,
     isAttached: false,
     provider: args.provider ?? "local",
+    region: args.region,
+    tunnelName,
     tunnelHandle,
     trace: args.trace ?? false
   };
@@ -3948,7 +4555,8 @@ Note: Unable to set window size (${windowWidth}x${windowHeight}). ${e}`;
 }
 async function startMobileSession(args) {
   const { platform: platform2, appPath, app, deviceName, noReset } = args;
-  if (!appPath && !app && noReset !== true) {
+  const isMobileBrowser = args.browser !== void 0;
+  if (!isMobileBrowser && !appPath && !app && noReset !== true) {
     return {
       content: [{
         type: "text",
@@ -3958,8 +4566,11 @@ async function startMobileSession(args) {
   }
   const provider = getProvider(args.provider ?? "local", args.platform);
   const serverConfig = provider.getConnectionConfig(args);
-  const mergedCapabilities = provider.buildCapabilities(args);
-  const tunnelHandle = args.browserstackLocal === true ? await provider.startTunnel?.(args) : void 0;
+  const effectiveTunnel = args.tunnel ?? args.browserstackLocal ?? args.saucelabsLocal ?? args.testmuLocal ?? false;
+  const tunnelEnabled = effectiveTunnel === true;
+  const tunnelName = tunnelEnabled && !args.tunnelName ? `wdio-mcp-${Date.now()}` : args.tunnelName;
+  const mergedCapabilities = provider.buildCapabilities({ ...args, tunnelName });
+  const tunnelHandle = tunnelEnabled ? await provider.startTunnel?.({ ...args, tunnelName }) : void 0;
   const browser = await remote({ ...serverConfig, capabilities: mergedCapabilities });
   const { sessionId } = browser;
   const shouldAutoDetach = provider.shouldAutoDetach(args);
@@ -3969,6 +4580,8 @@ async function startMobileSession(args) {
     capabilities: mergedCapabilities,
     isAttached: shouldAutoDetach,
     provider: args.provider ?? "local",
+    region: args.region,
+    tunnelName,
     tunnelHandle,
     trace: args.trace ?? false
   };
@@ -3983,14 +4596,16 @@ async function startMobileSession(args) {
   if (args.trace) {
     startTrace(sessionId, mergedCapabilities, sessionType);
   }
-  const appInfo = appPath ? `
+  const sessionKind = isMobileBrowser ? "mobile browser" : "app";
+  const appInfo = isMobileBrowser ? `
+Browser: ${args.browser}` : appPath ? `
 App: ${appPath}` : "\nApp: (connected to running app)";
   const detachNote = shouldAutoDetach ? "\n\n(Auto-detach enabled: session will be preserved on close. Use close_session({ detach: false }) to force terminate.)" : "";
   return {
     content: [
       {
         type: "text",
-        text: `${platform2} app session started with sessionId: ${sessionId}
+        text: `${platform2} ${sessionKind} session started with sessionId: ${sessionId}
 Device: ${deviceName}${appInfo}
 Appium Server: ${serverConfig.hostname}:${serverConfig.port}${serverConfig.path}${detachNote}`
       }
@@ -4152,51 +4767,163 @@ var switchFrameTool = async ({
   }
 };
 
-// src/tools/browserstack.tool.ts
-import { existsSync as existsSync2, createReadStream } from "fs";
+// src/tools/cloud-provider.tool.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
 import { z as z17 } from "zod";
-var BS_API = "https://api-cloud.browserstack.com";
-function getAuth() {
-  const user = process.env.BROWSERSTACK_USERNAME;
-  const key = process.env.BROWSERSTACK_ACCESS_KEY;
-  if (!user || !key) return null;
-  return Buffer.from(`${user}:${key}`).toString("base64");
-}
 function formatAppList(apps) {
   if (apps.length === 0) return "No apps found.";
   return apps.map((a) => {
-    const id = a.custom_id ? ` [${a.custom_id}]` : "";
-    return `${a.app_name} v${a.app_version}${id} \u2014 ${a.app_url} (${a.uploaded_at})`;
+    const id = a.customId ? ` [${a.customId}]` : "";
+    const ts = a.uploadedAt ?? "unknown";
+    return `${a.name}${id} \u2014 ${a.ref} (${ts})`;
   }).join("\n");
 }
+var PROVIDER_CONFIGS = {
+  browserstack: {
+    name: "BrowserStack",
+    apiBase: "https://api-cloud.browserstack.com",
+    credsEnvNames: ["BROWSERSTACK_USERNAME", "BROWSERSTACK_ACCESS_KEY"],
+    listPath: "/app-automate/recent_apps",
+    supportsOrgWide: true,
+    parseListResponse: (raw) => {
+      const apps = Array.isArray(raw) ? raw : [];
+      return apps.map((a) => ({
+        name: `${a.app_name}`,
+        ref: `${a.app_url}`,
+        uploadedAt: `${a.uploaded_at}`,
+        customId: a.custom_id
+      }));
+    },
+    uploadPath: "/app-automate/upload",
+    uploadField: "file",
+    parseUploadResponse: (raw, fileName) => {
+      const data = raw;
+      return { appRef: data.app_url, appName: fileName };
+    }
+  },
+  saucelabs: {
+    name: "Sauce Labs",
+    apiBase: "https://api.eu-central-1.saucelabs.com",
+    // region overridden via param
+    credsEnvNames: ["SAUCE_USERNAME", "SAUCE_ACCESS_KEY"],
+    listPath: "/v1/storage/files",
+    supportsOrgWide: false,
+    parseListResponse: (raw) => {
+      const data = raw;
+      return (data.items ?? []).map((a) => ({
+        name: a.name,
+        ref: `storage:filename=${a.name}`,
+        uploadedAt: a.uploadTimestamp ? new Date(a.uploadTimestamp).toISOString() : void 0,
+        customId: a.customId
+      }));
+    },
+    uploadPath: "/v1/storage/upload",
+    uploadField: "payload",
+    parseUploadResponse: (raw, fileName) => {
+      const data = raw;
+      const name = data.item?.name ?? fileName;
+      return { appRef: `storage:filename=${name}`, appName: name };
+    }
+  },
+  testmu: {
+    name: "TestMu",
+    apiBase: "https://manual-api.lambdatest.com",
+    credsEnvNames: ["TESTMU_USERNAME", "TESTMU_ACCESS_KEY"],
+    listPath: "/app/data",
+    supportsOrgWide: false,
+    parseListResponse: (raw) => {
+      if (raw === null || raw === void 0 || typeof raw !== "object") return [];
+      const data = raw;
+      const apps = data.data ?? (Array.isArray(raw) ? raw : []);
+      return apps.map((a) => ({
+        name: a.name ?? a.app_name ?? "unknown",
+        ref: a.app_id ? `lt://${a.app_id}` : `lt://${a.custom_id ?? "unknown"}`,
+        uploadedAt: a.updated_at,
+        customId: a.custom_id
+      }));
+    },
+    uploadPath: "/app/upload/realDevice",
+    uploadField: "appFile",
+    parseUploadResponse: (raw, fileName) => {
+      const data = raw;
+      const ref = data.app_id ? `lt://${data.app_id}` : data.app_url ?? "unknown";
+      return { appRef: ref, appName: data.name ?? fileName };
+    }
+  }
+};
+function getProviderConfig(provider, region) {
+  const base = PROVIDER_CONFIGS[provider];
+  if (!base) return { error: `Unknown provider: ${provider}` };
+  const [userEnv, keyEnv] = base.credsEnvNames;
+  const user = process.env[userEnv];
+  const key = process.env[keyEnv];
+  if (!user || !key) {
+    const vars = base.credsEnvNames.join(" and ");
+    return { error: `Missing credentials: set ${vars} environment variables.` };
+  }
+  const config = provider === "saucelabs" ? { ...base, apiBase: `https://api.${region ?? "eu-central-1"}.saucelabs.com` } : base;
+  return { config, auth: basicAuth(user, key) };
+}
 var listAppsToolDefinition = {
   name: "list_apps",
-  description: "List apps uploaded to BrowserStack App Automate. Reads BROWSERSTACK_USERNAME and BROWSERSTACK_ACCESS_KEY from environment.",
-  annotations: { title: "List BrowserStack Apps", readOnlyHint: true, idempotentHint: true },
+  description: "List apps uploaded to a cloud provider (BrowserStack App Automate, Sauce Labs App Storage, or TestMu Real Device Cloud). Reads provider-specific credentials from environment.",
+  annotations: { title: "List Cloud Provider Apps", readOnlyHint: true, idempotentHint: true },
   inputSchema: {
+    provider: z17.enum(["browserstack", "saucelabs", "testmu"]).describe("Cloud provider"),
     sortBy: z17.enum(["app_name", "uploaded_at"]).optional().default("uploaded_at").describe("Sort order for results"),
-    organizationWide: coerceBoolean.optional().default(false).describe("List apps uploaded by all users in the organization (uses recent_group_apps endpoint). Defaults to false (own uploads only)."),
-    limit: z17.number().int().min(1).optional().default(20).describe("Maximum number of apps to return (only applies when organizationWide is true, default 20)")
+    organizationWide: coerceBoolean.optional().default(false).describe("(BrowserStack only) List apps uploaded by all users in the organization. Defaults to false (own uploads only)."),
+    limit: z17.number().int().min(1).optional().default(20).describe("Maximum number of apps to return (only applies when organizationWide is true, default 20)"),
+    region: z17.enum(["us-west-1", "eu-central-1", "apac-southeast-1"]).optional().default("eu-central-1").describe("Sauce Labs region (default: eu-central-1)")
   }
 };
-var listAppsTool = async ({ sortBy = "uploaded_at", organizationWide = false, limit = 20 }) => {
-  const auth = getAuth();
-  if (!auth) {
-    return { isError: true, content: [{ type: "text", text: "Missing credentials: set BROWSERSTACK_USERNAME and BROWSERSTACK_ACCESS_KEY environment variables." }] };
+var listAppsTool = async (args) => {
+  const { provider, sortBy = "uploaded_at", organizationWide = false, limit = 20, region = "eu-central-1" } = args;
+  const resolved = getProviderConfig(provider, region);
+  if ("error" in resolved) {
+    return { isError: true, content: [{ type: "text", text: resolved.error }] };
   }
+  const { config, auth } = resolved;
   try {
-    let url = `${BS_API}/app-automate/${organizationWide ? "recent_group_apps" : "recent_apps"}`;
-    if (organizationWide && limit) url += `?limit=${limit}`;
-    const res = await fetch(url, {
-      headers: { Authorization: `Basic ${auth}` }
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      return { isError: true, content: [{ type: "text", text: `BrowserStack API error ${res.status}: ${body}` }] };
+    let url = `${config.apiBase}${config.listPath}`;
+    if (config.supportsOrgWide && organizationWide) {
+      url = `${config.apiBase}/app-automate/recent_group_apps?limit=${limit}`;
+    }
+    let apps = [];
+    if (provider === "testmu") {
+      const errors = [];
+      for (const platform2 of ["android", "ios"]) {
+        try {
+          const res = await fetch(`${url}?type=${platform2}`, {
+            headers: { Authorization: `Basic ${auth}` }
+          });
+          if (res.ok) {
+            const raw = await res.json();
+            apps.push(...config.parseListResponse(raw));
+          } else {
+            const body = await res.text();
+            errors.push(`${config.name} API error ${res.status} (${platform2}): ${body}`);
+          }
+        } catch (e) {
+          errors.push(String(e));
+        }
+      }
+      if (apps.length === 0 && errors.length > 0) {
+        const message = errors.length === 1 ? errors[0] : `All platform fetches failed:
+${errors.map((e) => `  - ${e}`).join("\n")}`;
+        return { isError: true, content: [{ type: "text", text: `Error listing apps: ${message}` }] };
+      }
+    } else {
+      const res = await fetch(url, {
+        headers: { Authorization: `Basic ${auth}` }
+      });
+      if (!res.ok) {
+        const body = await res.text();
+        return { isError: true, content: [{ type: "text", text: `${config.name} API error ${res.status}: ${body}` }] };
+      }
+      const raw = await res.json();
+      apps = config.parseListResponse(raw);
     }
-    const raw = await res.json();
-    let apps = Array.isArray(raw) ? raw : [];
-    apps = sortBy === "app_name" ? apps.sort((a, b) => a.app_name.localeCompare(b.app_name)) : apps.sort((a, b) => new Date(b.uploaded_at).getTime() - new Date(a.uploaded_at).getTime());
+    apps = sortBy === "app_name" ? apps.sort((a, b) => a.name.localeCompare(b.name)) : apps.sort((a, b) => (b.uploadedAt ?? "").localeCompare(a.uploadedAt ?? ""));
     return { content: [{ type: "text", text: formatAppList(apps) }] };
   } catch (e) {
     return { isError: true, content: [{ type: "text", text: `Error listing apps: ${e}` }] };
@@ -4204,28 +4931,33 @@ var listAppsTool = async ({ sortBy = "uploaded_at", organizationWide = false, li
 };
 var uploadAppToolDefinition = {
   name: "upload_app",
-  description: "Upload a local .apk or .ipa to BrowserStack App Automate. Returns a bs:// URL for use in start_session.",
-  annotations: { title: "Upload App to BrowserStack", destructiveHint: false },
+  description: "Upload a local .apk or .ipa to a cloud provider (BrowserStack, Sauce Labs, or TestMu). Returns the app URL for use in start_session.",
+  annotations: { title: "Upload App to Cloud Provider", destructiveHint: false },
   inputSchema: {
+    provider: z17.enum(["browserstack", "saucelabs", "testmu"]).describe("Cloud provider"),
     path: z17.string().describe("Absolute path to the .apk or .ipa file"),
-    customId: z17.string().optional().describe("Optional custom ID for the app (used to reference it later)")
+    customId: z17.string().optional().describe("Optional custom ID for the app (used to reference it later)"),
+    region: z17.enum(["us-west-1", "eu-central-1", "apac-southeast-1"]).optional().default("eu-central-1").describe("Sauce Labs region (default: eu-central-1)")
   }
 };
-var uploadAppTool = async ({ path, customId }) => {
-  const auth = getAuth();
-  if (!auth) {
-    return { isError: true, content: [{ type: "text", text: "Missing credentials: set BROWSERSTACK_USERNAME and BROWSERSTACK_ACCESS_KEY environment variables." }] };
+var uploadAppTool = async (args) => {
+  const { provider, path, customId, region = "eu-central-1" } = args;
+  const resolved = getProviderConfig(provider, region);
+  if ("error" in resolved) {
+    return { isError: true, content: [{ type: "text", text: resolved.error }] };
   }
+  const { config, auth } = resolved;
   if (!existsSync2(path)) {
     return { isError: true, content: [{ type: "text", text: `File not found: ${path}` }] };
   }
+  const fileName = path.split("/").pop() ?? "app";
   try {
     const form = new FormData();
-    const stream = createReadStream(path);
-    const fileName = path.split("/").pop() ?? "app";
-    form.append("file", new Blob([stream]), fileName);
+    const fileBuffer = readFileSync(path);
+    const fileBlob = new Blob([fileBuffer], { type: "application/octet-stream" });
+    form.append(config.uploadField, fileBlob, fileName);
     if (customId) form.append("custom_id", customId);
-    const res = await fetch(`${BS_API}/app-automate/upload`, {
+    const res = await fetch(`${config.apiBase}${config.uploadPath}`, {
       method: "POST",
       headers: { Authorization: `Basic ${auth}` },
       body: form
@@ -4234,13 +4966,14 @@ var uploadAppTool = async ({ path, customId }) => {
       const body = await res.text();
       return { isError: true, content: [{ type: "text", text: `Upload failed ${res.status}: ${body}` }] };
     }
-    const data = await res.json();
-    const customIdNote = data.custom_id ? `
-Custom ID: ${data.custom_id}` : "";
+    const raw = await res.json();
+    const { appRef } = config.parseUploadResponse(raw, fileName);
+    const customIdNote = customId ? `
+Custom ID: ${customId}` : "";
     return { content: [{ type: "text", text: `Upload successful.
-App URL: ${data.app_url}${customIdNote}
+App: ${appRef}${customIdNote}
 
-Use this URL as the "app" parameter in start_session with provider: "browserstack".` }] };
+Use "${appRef}" as the "app" parameter in start_session with provider: "${provider}".` }] };
   } catch (e) {
     return { isError: true, content: [{ type: "text", text: `Error uploading app: ${e}` }] };
   }
@@ -4431,6 +5164,8 @@ function createServer() {
   registerResource(sessionStepsResource);
   registerResource(sessionCodeResource);
   registerResource(browserstackLocalBinaryResource);
+  registerResource(saucelabsLocalBinaryResource);
+  registerResource(testmuLocalBinaryResource);
   registerResource(capabilitiesResource);
   registerResource(elementsResource);
   registerResource(accessibilityResource);