@kolatts/pncli 5.4.0 → 6.0.0

package/dist/cli.js

@@ -28,11 +28,13 @@ import {
   windowsListCredentials,
   writeGlobalConfig,
   writeRepoConfig
-} from "./chunk-L6OY2546.js";
+} from "./chunk-WDWAPTVC.js";
 import {
+  configureTls,
   createHttpClient,
+  describeFetchError,
   validateAlationAccessToken
-} from "./chunk-2J2HAFKO.js";
+} from "./chunk-4FR4WGNR.js";
 import {
   ExitCode,
   fail,
@@ -599,9 +601,9 @@ var BitbucketClient = class {
       )
     );
   }
-  async getPR(project, repo, id) {
+  async getPR(project, repo, id2) {
     return this.http.bitbucket(
-      `${API}/projects/${project}/repos/${repo}/pull-requests/${id}`
+      `${API}/projects/${project}/repos/${repo}/pull-requests/${id2}`
     );
   }
   async createPR(opts) {
@@ -653,9 +655,9 @@ var BitbucketClient = class {
       { method: "POST", params, body }
     );
   }
-  async declinePR(project, repo, id, version) {
+  async declinePR(project, repo, id2, version) {
     return this.http.bitbucket(
-      `${API}/projects/${project}/repos/${repo}/pull-requests/${id}/decline`,
+      `${API}/projects/${project}/repos/${repo}/pull-requests/${id2}/decline`,
       { method: "POST", params: { version } }
     );
   }
@@ -2885,9 +2887,9 @@ function parseFieldsFile(filePath, fieldMap) {
 }
 function translateFieldErrors(err, fieldMap) {
   if (!(err instanceof PncliError) || fieldMap.byId.size === 0) return err;
-  const translated = err.message.replace(/\bcustomfield_\d+\b/g, (id) => {
-    const def = fieldMap.byId.get(id);
-    return def ? `${def.name} (${id})` : id;
+  const translated = err.message.replace(/\bcustomfield_\d+\b/g, (id2) => {
+    const def = fieldMap.byId.get(id2);
+    return def ? `${def.name} (${id2})` : id2;
   });
   if (translated === err.message) return err;
   return new PncliError(translated, err.status, err.url);
@@ -4255,8 +4257,8 @@ var ConfluenceClient = class {
     this.http = http;
   }
   http;
-  async getPage(id, expand = "body.storage,version,space,ancestors") {
-    return this.http.confluence(`${API3}/content/${id}`, {
+  async getPage(id2, expand = "body.storage,version,space,ancestors") {
+    return this.http.confluence(`${API3}/content/${id2}`, {
       params: { expand }
     });
   }
@@ -4274,16 +4276,16 @@ var ConfluenceClient = class {
       });
     }, opts.limit);
   }
-  async getPageChildren(id) {
+  async getPageChildren(id2) {
     return this.http.confluencePaginate(async (start, limit) => {
-      return this.http.confluence(`${API3}/content/${id}/child/page`, {
+      return this.http.confluence(`${API3}/content/${id2}/child/page`, {
         params: { expand: "version", start, limit }
       });
     });
   }
-  async getLabels(id) {
+  async getLabels(id2) {
     return this.http.confluencePaginate(async (start, limit) => {
-      return this.http.confluence(`${API3}/content/${id}/label`, {
+      return this.http.confluence(`${API3}/content/${id2}/label`, {
         params: { start, limit }
       });
     });
@@ -4316,7 +4318,7 @@ var ConfluenceClient = class {
       body
     });
   }
-  async updatePage(id, opts) {
+  async updatePage(id2, opts) {
     const body = {
       version: { number: opts.version },
       type: "page",
@@ -4331,13 +4333,13 @@ var ConfluenceClient = class {
         }
       };
     }
-    return this.http.confluence(`${API3}/content/${id}`, {
+    return this.http.confluence(`${API3}/content/${id2}`, {
       method: "PUT",
       body
     });
   }
-  async deletePage(id) {
-    return this.http.confluence(`${API3}/content/${id}`, { method: "DELETE" });
+  async deletePage(id2) {
+    return this.http.confluence(`${API3}/content/${id2}`, { method: "DELETE" });
   }
   async listComments(pageId) {
     return this.http.confluencePaginate(async (start, limit) => {
@@ -4422,8 +4424,8 @@ var ConfluenceClient = class {
   async deleteAttachment(attachmentId) {
     return this.http.confluence(`${API3}/content/${attachmentId}`, { method: "DELETE" });
   }
-  async getPageHistory(id) {
-    return this.http.confluence(`${API3}/content/${id}/history`);
+  async getPageHistory(id2) {
+    return this.http.confluence(`${API3}/content/${id2}/history`);
   }
   async convertToStorage(value, fromRepresentation = "markdown") {
     const result = await this.http.confluence(
@@ -5115,9 +5117,9 @@ function resolveProject2(config, cliProject) {
   const project = cliProject ?? config.defaults.sde.project;
   if (!project) throw new PncliError("No project specified. Use --project or set defaults.sde.project in config.");
   if (!/^\d+$/.test(project)) throw new PncliError(`Invalid project ID: "${project}". SDElements project IDs must be positive integers.`);
-  const id = parseInt(project, 10);
-  if (id <= 0) throw new PncliError(`Invalid project ID: "${project}". SDElements project IDs must be positive integers.`);
-  return id;
+  const id2 = parseInt(project, 10);
+  if (id2 <= 0) throw new PncliError(`Invalid project ID: "${project}". SDElements project IDs must be positive integers.`);
+  return id2;
 }
 function parsePage(val, flag) {
   const n = parseInt(val, 10);
@@ -6045,7 +6047,7 @@ async function checkOsvConnectivity() {
   } catch (err) {
     return {
       reachable: false,
-      error: err instanceof Error ? err.message : String(err)
+      error: describeFetchError(err)
     };
   }
 }
@@ -6250,7 +6252,7 @@ async function checkSonatypeConnectivity() {
   } catch (err) {
     return {
       reachable: false,
-      error: err instanceof Error ? err.message : String(err)
+      error: describeFetchError(err)
     };
   }
 }
@@ -6314,10 +6316,10 @@ function mapViolationToVuln(violation) {
   const cveRefs = violation.constraintViolations.flatMap(
     (cv) => cv.reasons.filter((r) => r.reference?.type === "VULNERABILITY").map((r) => r.reference.value)
   );
-  const id = cveRefs[0] ?? violation.policyId;
+  const id2 = cveRefs[0] ?? violation.policyId;
   const severity = threatLevelToSeverity(violation.policyThreatLevel);
   return {
-    id,
+    id: id2,
     summary: violation.policyName,
     severity,
     cvss: null,
@@ -6473,7 +6475,7 @@ async function checkSonatypeIqConnectivity(baseUrl, userCode, passcode) {
     return {
       reachable: false,
       authenticated: false,
-      error: err instanceof Error ? err.message : String(err)
+      error: describeFetchError(err)
     };
   }
 }
@@ -6533,7 +6535,7 @@ async function checkArtifactoryConnectivity(config) {
       reachable: false,
       authenticated: false,
       configured: true,
-      error: err instanceof Error ? err.message : String(err)
+      error: describeFetchError(err)
     };
   }
 }
@@ -7080,9 +7082,9 @@ var AdoWorkClient = class {
     this.http = http;
   }
   http;
-  async getWorkItem(collection, id) {
+  async getWorkItem(collection, id2) {
     return this.http.ado(
-      `/${encodeURIComponent(collection)}/_apis/wit/workitems/${id}?api-version=${API6}&$expand=all`
+      `/${encodeURIComponent(collection)}/_apis/wit/workitems/${id2}?api-version=${API6}&$expand=all`
     );
   }
   async createWorkItem(collection, project, type, patch) {
@@ -7091,9 +7093,9 @@ var AdoWorkClient = class {
       { method: "POST", body: patch, headers: { "Content-Type": "application/json-patch+json" } }
     );
   }
-  async updateWorkItem(collection, id, patch) {
+  async updateWorkItem(collection, id2, patch) {
     return this.http.ado(
-      `/${encodeURIComponent(collection)}/_apis/wit/workitems/${id}?api-version=${API6}`,
+      `/${encodeURIComponent(collection)}/_apis/wit/workitems/${id2}?api-version=${API6}`,
       { method: "PATCH", body: patch, headers: { "Content-Type": "application/json-patch+json" } }
     );
   }
@@ -7115,23 +7117,23 @@ var AdoWorkClient = class {
       { method: "POST", body: { text } }
     );
   }
-  async addTags(collection, id, tags) {
-    const item = await this.getWorkItem(collection, id);
+  async addTags(collection, id2, tags) {
+    const item = await this.getWorkItem(collection, id2);
     const existing = item.fields["System.Tags"] ?? "";
     const current = existing.split(";").map((t) => t.trim()).filter(Boolean);
     const lowerSet = new Set(current.map((t) => t.toLowerCase()));
     const toAdd = tags.filter((t) => !lowerSet.has(t.toLowerCase()));
     const merged = [...current, ...toAdd];
     const patch = [{ op: "add", path: "/fields/System.Tags", value: merged.join("; ") }];
-    return this.updateWorkItem(collection, id, patch);
+    return this.updateWorkItem(collection, id2, patch);
   }
-  async removeTags(collection, id, tags) {
-    const item = await this.getWorkItem(collection, id);
+  async removeTags(collection, id2, tags) {
+    const item = await this.getWorkItem(collection, id2);
     const existing = item.fields["System.Tags"] ?? "";
     const lower = new Set(tags.map((t) => t.toLowerCase()));
     const remaining = existing.split(";").map((t) => t.trim()).filter((t) => t && !lower.has(t.toLowerCase()));
     const patch = [{ op: "add", path: "/fields/System.Tags", value: remaining.join("; ") }];
-    return this.updateWorkItem(collection, id, patch);
+    return this.updateWorkItem(collection, id2, patch);
   }
   async listWorkItemTypes(collection, project) {
     const result = await this.http.ado(
@@ -7272,6 +7274,422 @@ function buildDefaultAliases(fields) {
   return aliases;
 }
 
+// src/services/saucelabs/commands.ts
+var SERVICE = "saucelabs";
+var RDA = "/rdc/v2";
+var TEAM_MGMT = "/team-management/v1";
+var BUILD_SOURCES = ["vdc", "rdc"];
+var BUILD_STATUSES = ["running", "error", "failed", "complete", "success"];
+var JOB_VISIBILITY = ["public", "public restricted", "share", "team", "private"];
+var PLATFORM_APIS = ["all", "appium", "webdriver"];
+var DEVICE_OS = ["ANDROID", "IOS"];
+var DEVICE_TYPES = ["PHONE", "TABLET"];
+var DEVICE_STATES = ["AVAILABLE", "IN_USE", "CLEANING", "MAINTENANCE", "REBOOTING", "OFFLINE"];
+var SESSION_STATES = ["PENDING", "CREATING", "ACTIVE", "CLOSING", "CLOSED", "ERRORED"];
+var ORIENTATIONS = ["PORTRAIT", "LANDSCAPE"];
+var STORAGE_KINDS = ["android", "ios"];
+function getHttp(program2) {
+  const opts = program2.optsWithGlobals();
+  return createHttpClient(
+    loadConfig({ configPath: opts.config }),
+    Boolean(opts.dryRun)
+  );
+}
+async function verifySauceLabsCredentials(http, timeoutMs) {
+  return http.saucelabs(
+    `/rest/v1.2/users/${encodeURIComponent(http.saucelabsUsername())}/concurrency`,
+    timeoutMs !== void 0 ? { timeoutMs } : {}
+  );
+}
+function parseIntOption(value, flag) {
+  if (value === void 0) return void 0;
+  const trimmed = value.trim();
+  if (!/^\d+$/.test(trimmed)) {
+    throw new PncliError(`Invalid ${flag} "${value}". Expected a non-negative integer.`, 1);
+  }
+  return Number(trimmed);
+}
+function parseUnixTime(value, flag) {
+  if (value === void 0) return void 0;
+  const trimmed = value.trim();
+  if (/^\d+$/.test(trimmed)) return Number(trimmed);
+  const ms = Date.parse(trimmed);
+  if (!Number.isFinite(ms)) {
+    throw new PncliError(`Invalid ${flag} "${value}". Expected Unix seconds or an ISO 8601 date such as 2026-09-01T00:00:00Z.`, 1);
+  }
+  return Math.floor(ms / 1e3);
+}
+function parseChoice(value, choices, flag) {
+  if (value === void 0) return void 0;
+  const match = choices.find((c) => c.toLowerCase() === value.trim().toLowerCase());
+  if (!match) {
+    throw new PncliError(`Invalid ${flag} "${value}". Expected one of: ${choices.join(", ")}.`, 1);
+  }
+  return match;
+}
+function collectList(value, previous = []) {
+  return [...previous, ...value.split(",").map((v) => v.trim()).filter(Boolean)];
+}
+function withRepeatedParam(path14, key, values) {
+  if (!values || values.length === 0) return path14;
+  const qs = values.map((v) => `${encodeURIComponent(key)}=${encodeURIComponent(v)}`).join("&");
+  return `${path14}${path14.includes("?") ? "&" : "?"}${qs}`;
+}
+function passedFlag(opts) {
+  if (opts.passed && opts.failed) throw new PncliError("Pass only one of --passed or --failed.", 1);
+  if (opts.passed) return true;
+  if (opts.failed) return false;
+  return void 0;
+}
+function requireBody(body, hint) {
+  if (Object.keys(body).length === 0) throw new PncliError(`Nothing to update. ${hint}`, 1);
+  return body;
+}
+function id(value) {
+  return encodeURIComponent(value.trim());
+}
+function countOf(data, key) {
+  const list = key ? data?.[key] : data;
+  return Array.isArray(list) ? list.length : void 0;
+}
+function registerSauceLabsCommands(program2) {
+  function run(action, fn) {
+    return async (...args) => {
+      const start = Date.now();
+      const { success: success2, fail: fail2 } = await import("./output-HDUIIXUI.js");
+      try {
+        success2(await fn(getHttp(program2), ...args), SERVICE, action, start);
+      } catch (err) {
+        fail2(err, SERVICE, action, start);
+      }
+    };
+  }
+  const sauce = program2.command("saucelabs").description("Sauce Labs (jobs, builds, real devices and device sessions, tunnels, platforms, app storage, teams)");
+  sauce.command("status").description("Sauce Labs service status (operational flag, wait time)").action(run("status", (http) => http.saucelabs("/rest/v1/info/status")));
+  sauce.command("concurrency").description("Concurrency allowed and in use for your organization and team (also verifies credentials)").action(run("concurrency", (http) => verifySauceLabsCredentials(http)));
+  sauce.command("platforms").description("Supported OS/browser/device platforms").option("--api <api>", "Automation API: all, appium, webdriver", "all").action(run("platforms", async (http, opts) => {
+    const api = parseChoice(opts.api, PLATFORM_APIS, "--api");
+    const data = await http.saucelabs(`/rest/v1/info/platforms/${api}`);
+    return { api, count: countOf(data), platforms: data };
+  }));
+  const job = sauce.command("job").description("Test jobs on Sauce virtual devices and desktop browsers (VDC)");
+  job.command("list").description("List your recent jobs").option("--limit <n>", "Maximum number of jobs to return").option("--skip <n>", "Number of jobs to skip").option("--from <time>", "Only jobs created after this time (Unix seconds or ISO 8601)").option("--to <time>", "Only jobs created before this time (Unix seconds or ISO 8601)").action(run("job-list", async (http, opts) => {
+    const params = {
+      limit: parseIntOption(opts.limit, "--limit"),
+      skip: parseIntOption(opts.skip, "--skip"),
+      from: parseUnixTime(opts.from, "--from"),
+      to: parseUnixTime(opts.to, "--to")
+    };
+    const data = await http.saucelabs(`/rest/v1/${id(http.saucelabsUsername())}/jobs`, { params });
+    return { count: countOf(data), jobs: data };
+  }));
+  job.command("get").description("Get one job: status, platform, timings, and log/video URLs").argument("<job-id>", "Job ID").action(run("job-get", (http, jobId) => http.saucelabs(`/rest/v1/${id(http.saucelabsUsername())}/jobs/${id(jobId)}`)));
+  job.command("update").description("Update a job's name, build, tags, result, or visibility").argument("<job-id>", "Job ID").option("--name <name>", "Job name").option("--build <build>", "Build name to group the job under").option("--tags <tags>", "Comma-separated tags; replaces the existing tags", collectList).option("--passed", "Mark the job as passed").option("--failed", "Mark the job as failed").option("--public <visibility>", "Visibility: public, public restricted, share, team, private").action(run("job-update", (http, jobId, opts) => {
+    const body = {};
+    if (opts.name !== void 0) body["name"] = opts.name;
+    if (opts.build !== void 0) body["build"] = opts.build;
+    if (opts.tags !== void 0) body["tags"] = opts.tags;
+    const passed = passedFlag(opts);
+    if (passed !== void 0) body["passed"] = passed;
+    const visibility = parseChoice(opts.public, JOB_VISIBILITY, "--public");
+    if (visibility !== void 0) body["public"] = visibility;
+    return http.saucelabs(`/rest/v1/${id(http.saucelabsUsername())}/jobs/${id(jobId)}`, {
+      method: "PUT",
+      body: requireBody(body, "Pass at least one of --name, --build, --tags, --passed/--failed, --public.")
+    });
+  }));
+  job.command("stop").description("Stop a running job").argument("<job-id>", "Job ID").action(run("job-stop", (http, jobId) => http.saucelabs(`/rest/v1/${id(http.saucelabsUsername())}/jobs/${id(jobId)}/stop`, { method: "PUT" })));
+  job.command("delete").description("Delete a job and all of its assets").argument("<job-id>", "Job ID").action(run("job-delete", async (http, jobId) => {
+    await http.saucelabs(`/rest/v1/${id(http.saucelabsUsername())}/jobs/${id(jobId)}`, { method: "DELETE" });
+    return { jobId, deleted: true };
+  }));
+  job.command("assets").description("List the asset files a job produced (logs, video, screenshots) \u2014 names only, no download").argument("<job-id>", "Job ID").action(run("job-assets", async (http, jobId) => {
+    const data = await http.saucelabs(
+      `/rest/v1/${id(http.saucelabsUsername())}/jobs/${id(jobId)}/assets`
+    );
+    return { jobId, assets: data };
+  }));
+  const rdcJob = sauce.command("rdc-job").description("Test jobs that ran on real devices");
+  rdcJob.command("list").description("List real-device jobs").option("--limit <n>", "Maximum number of jobs to return").option("--offset <n>", "Number of jobs to skip").option("--live", "Only manual (live) tests").action(run("rdc-job-list", (http, opts) => http.saucelabs("/v1/rdc/jobs", {
+    params: {
+      limit: parseIntOption(opts.limit, "--limit"),
+      offset: parseIntOption(opts.offset, "--offset"),
+      type: opts.live ? "LIVE" : void 0
+    }
+  })));
+  rdcJob.command("get").description("Get one real-device job: device, result, timings, and log URLs").argument("<job-id>", "Job ID").action(run("rdc-job-get", (http, jobId) => http.saucelabs(`/v1/rdc/jobs/${id(jobId)}`)));
+  rdcJob.command("update").description("Update a real-device job's name, build, tags, or result").argument("<job-id>", "Job ID").option("--name <name>", "Job name").option("--build <build>", "Build name").option("--tags <tags>", "Comma-separated tags; replaces the existing tags", collectList).option("--passed", "Mark the job as passed").option("--failed", "Mark the job as failed").action(run("rdc-job-update", (http, jobId, opts) => {
+    const body = {};
+    if (opts.name !== void 0) body["name"] = opts.name;
+    if (opts.build !== void 0) body["build"] = opts.build;
+    if (opts.tags !== void 0) body["tags"] = opts.tags;
+    const passed = passedFlag(opts);
+    if (passed !== void 0) body["passed"] = passed;
+    return http.saucelabs(`/v1/rdc/jobs/${id(jobId)}`, {
+      method: "PUT",
+      body: requireBody(body, "Pass at least one of --name, --build, --tags, --passed/--failed.")
+    });
+  }));
+  rdcJob.command("stop").description("Stop a running real-device job").argument("<job-id>", "Job ID").action(run("rdc-job-stop", async (http, jobId) => {
+    await http.saucelabs(`/v1/rdc/jobs/${id(jobId)}/stop`, { method: "PUT" });
+    return { jobId, stopped: true };
+  }));
+  rdcJob.command("delete").description("Delete a real-device job (owner, team admin, or org admin only)").argument("<job-id>", "Job ID").action(run("rdc-job-delete", async (http, jobId) => {
+    await http.saucelabs(`/v1/rdc/jobs/${id(jobId)}`, { method: "DELETE" });
+    return { jobId, deleted: true };
+  }));
+  const build = sauce.command("build").description("Builds (groups of jobs) on virtual (vdc) or real (rdc) devices");
+  build.command("list").description("List builds").option("--source <source>", "Build source: vdc (virtual devices) or rdc (real devices)", "vdc").option("--status <status>", "Filter by status (repeatable or comma-separated): running, error, failed, complete, success", collectList).option("--name <name>", "Filter by build name").option("--start <time>", "Only builds started after this time (Unix seconds or ISO 8601)").option("--end <time>", "Only builds ended before this time (Unix seconds or ISO 8601)").option("--limit <n>", "Maximum number of builds to return").option("--offset <n>", "Number of builds to skip").option("--sort <order>", "Sort by creation time: asc or desc").action(run("build-list", async (http, opts) => {
+    const source = parseChoice(opts.source, BUILD_SOURCES, "--source");
+    const statuses = opts.status?.map((s) => parseChoice(s, BUILD_STATUSES, "--status"));
+    const data = await http.saucelabs(withRepeatedParam(`/v2/builds/${source}/`, "status", statuses), {
+      params: {
+        name: opts.name,
+        start: parseUnixTime(opts.start, "--start"),
+        end: parseUnixTime(opts.end, "--end"),
+        limit: parseIntOption(opts.limit, "--limit"),
+        offset: parseIntOption(opts.offset, "--offset"),
+        sort: parseChoice(opts.sort, ["asc", "desc"], "--sort")
+      }
+    });
+    return { source, count: countOf(data, "builds"), builds: data?.builds ?? [] };
+  }));
+  build.command("get").description("Get one build with its job counts").argument("<build-id>", "Build ID").option("--source <source>", "Build source: vdc (virtual devices) or rdc (real devices)", "vdc").action(run("build-get", (http, buildId, opts) => {
+    const source = parseChoice(opts.source, BUILD_SOURCES, "--source");
+    return http.saucelabs(`/v2/builds/${source}/${id(buildId)}/`);
+  }));
+  build.command("jobs").description("List the jobs in a build").argument("<build-id>", "Build ID").option("--source <source>", "Build source: vdc (virtual devices) or rdc (real devices)", "vdc").option("--failed", "Only failed jobs").option("--errored", "Only errored jobs").option("--passed", "Only passed jobs").option("--running", "Only running jobs").option("--queued", "Only queued jobs").option("--completed", "Only completed jobs").option("--finished", "Only finished jobs").option("--faulty", "Only faulty (failed or errored) jobs").option("--modified-since <time>", "Only jobs modified since this ISO 8601 time").action(run("build-jobs", async (http, buildId, opts) => {
+    const source = parseChoice(opts.source, BUILD_SOURCES, "--source");
+    const params = { modified_since: opts["modifiedSince"] };
+    for (const flag of ["failed", "errored", "passed", "running", "queued", "completed", "finished", "faulty"]) {
+      if (opts[flag]) params[flag] = true;
+    }
+    const data = await http.saucelabs(`/v2/builds/${source}/${id(buildId)}/jobs/`, { params });
+    return { buildId, source, count: countOf(data, "jobs"), jobs: data?.jobs ?? [] };
+  }));
+  build.command("for-job").description("Get the build a job belongs to").argument("<job-id>", "Job ID").option("--source <source>", "Build source: vdc (virtual devices) or rdc (real devices)", "vdc").action(run("build-for-job", (http, jobId, opts) => {
+    const source = parseChoice(opts.source, BUILD_SOURCES, "--source");
+    return http.saucelabs(`/v2/builds/${source}/jobs/${id(jobId)}/build/`);
+  }));
+  const device = sauce.command("device").description("Real-device catalog and live availability");
+  device.command("list").description("List real devices your account can use").option("--name <regex>", 'Device name (regex), for example "iPhone.*" or "Samsung Galaxy S2[34].*"').option("--os <os>", "Operating system: android or ios").option("--os-version <version>", 'OS major version or regex, for example 17 or "1[78]"').option("--type <type>", "Device type: phone or tablet").action(run("device-list", async (http, opts) => {
+    const data = await http.saucelabs(`${RDA}/devices`, {
+      params: {
+        deviceName: opts.name,
+        os: parseChoice(opts.os, DEVICE_OS, "--os"),
+        osVersion: opts.osVersion,
+        deviceType: parseChoice(opts.type, DEVICE_TYPES, "--type")
+      }
+    });
+    return { count: countOf(data), devices: data };
+  }));
+  device.command("get").description("Get one device's full descriptor (hardware, OS, screen)").argument("<device-id>", "Device ID, for example iPhone_15_real").action(run("device-get", (http, deviceId) => http.saucelabs(`/v1/rdc/devices/${id(deviceId)}`)));
+  device.command("status").description("Live availability of real devices (AVAILABLE, IN_USE, CLEANING, ...)").option("--state <state>", "Only devices in this state: available, in_use, cleaning, maintenance, rebooting, offline").option("--name <regex>", "Device name (regex)").option("--private-only", "Only your organization's private devices").action(run("device-status", async (http, opts) => {
+    const data = await http.saucelabs(`${RDA}/devices/status`, {
+      params: {
+        state: parseChoice(opts.state, DEVICE_STATES, "--state"),
+        deviceName: opts.name,
+        privateOnly: opts.privateOnly ? true : void 0
+      }
+    });
+    return { count: countOf(data, "devices"), devices: data?.devices ?? [] };
+  }));
+  const session = sauce.command("session").description("Reserve a real device and drive it over the API (open URLs, install apps, ADB shell, tests)");
+  const sessionPath = (sessionId) => `${RDA}/sessions/${id(sessionId)}`;
+  const deviceAction = (sessionId, action) => `${sessionPath(sessionId)}/device/${action}`;
+  session.command("list").description("List your device sessions").option("--state <state>", "Only sessions in this state: pending, creating, active, closing, closed, errored").option("--device-name <regex>", "Device name (regex)").action(run("session-list", async (http, opts) => {
+    const data = await http.saucelabs(`${RDA}/sessions`, {
+      params: { state: parseChoice(opts.state, SESSION_STATES, "--state"), deviceName: opts.deviceName }
+    });
+    return { count: countOf(data, "sessions"), sessions: data?.sessions ?? [] };
+  }));
+  session.command("create").description("Reserve a real device. Returns immediately in PENDING state unless --wait is passed").option("--device-name <regex>", 'Device name or regex, for example "iPhone 15.*" (any device when omitted)').option("--os <os>", "Operating system: android or ios").option("--tunnel-name <name>", "Route device traffic through this Sauce Connect tunnel").option("--tunnel-owner <username>", "Owner of a shared tunnel").option("--duration <iso8601>", "Session length as an ISO 8601 duration, for example PT30M (default 6h; public devices cap at 1h)").option("--wait", "Poll until the session is ACTIVE (or fails) before returning").option("--timeout <seconds>", "Maximum seconds to wait with --wait", "300").action(run("session-create", async (http, opts) => {
+    if (opts.tunnelOwner && !opts.tunnelName) throw new PncliError("--tunnel-owner requires --tunnel-name.", 1);
+    const timeoutSeconds = parseIntOption(opts.timeout, "--timeout") ?? 300;
+    const deviceQuery = {};
+    if (opts.deviceName) deviceQuery["deviceName"] = opts.deviceName;
+    const os4 = parseChoice(opts.os, ["android", "ios"], "--os");
+    if (os4) deviceQuery["os"] = os4;
+    const configuration = {};
+    if (opts.tunnelName) {
+      configuration["tunnel"] = { name: opts.tunnelName, ...opts.tunnelOwner ? { owner: opts.tunnelOwner } : {} };
+    }
+    if (opts.duration) configuration["sessionDuration"] = opts.duration;
+    const body = { device: deviceQuery };
+    if (Object.keys(configuration).length > 0) body["configuration"] = configuration;
+    const created = await http.saucelabs(`${RDA}/sessions`, { method: "POST", body });
+    if (!opts.wait) return created;
+    return waitForSession(http, created.id, timeoutSeconds);
+  }));
+  session.command("get").description("Get a session: state, device, expiry, Appium URL, and live-view link").argument("<session-id>", "Session ID").action(run("session-get", (http, sessionId) => http.saucelabs(sessionPath(sessionId))));
+  session.command("delete").description("Close a session and release the device").argument("<session-id>", "Session ID").option("--reboot", "Reboot the device after closing (private devices only)").action(run("session-delete", (http, sessionId, opts) => http.saucelabs(sessionPath(sessionId), {
+    method: "DELETE",
+    params: { rebootDevice: opts.reboot ? true : void 0 }
+  })));
+  session.command("open-url").description("Open a URL on the device (Chrome on Android; Safari or a deep link on iOS)").argument("<session-id>", "Session ID").argument("<url>", "URL to open").action(run("session-open-url", async (http, sessionId, url) => {
+    await http.saucelabs(deviceAction(sessionId, "openUrl"), { method: "POST", body: { url } });
+    return { sessionId, url, opened: true };
+  }));
+  session.command("shell").description("Run an ADB shell command on an Android device (public devices allow only a safe subset)").argument("<session-id>", "Session ID").argument("<command>", 'Shell command without the "adb shell" prefix, for example "getprop ro.build.version.release"').action(run("session-shell", async (http, sessionId, command) => {
+    const data = await http.saucelabs(deviceAction(sessionId, "executeShellCommand"), {
+      method: "POST",
+      body: { adbShellCommand: command },
+      timeoutMs: 12e4
+    });
+    return { sessionId, command, stdout: data?.stdout ?? "" };
+  }));
+  session.command("install-app").description("Install an app from Sauce app storage onto the device (runs in the background)").argument("<session-id>", "Session ID").argument("<app>", "App reference: storage:<file-id> or storage:filename=<name>").option("--launch", "Launch the app once installed").option("--no-instrumentation", "Install without Sauce instrumentation").action(run("session-install-app", (http, sessionId, app, opts) => http.saucelabs(deviceAction(sessionId, "installApp"), {
+    method: "POST",
+    body: { app, enableInstrumentation: opts.instrumentation, launchAfterInstall: Boolean(opts.launch) }
+  })));
+  session.command("installations").description("List app installations on the device and their status").argument("<session-id>", "Session ID").action(run("session-installations", (http, sessionId) => http.saucelabs(deviceAction(sessionId, "listAppInstallations"), { method: "POST" })));
+  const appIdentity = (opts) => {
+    if (Boolean(opts.bundleId) === Boolean(opts.packageName)) {
+      throw new PncliError("Pass exactly one of --bundle-id (iOS) or --package-name (Android).", 1);
+    }
+    return opts.bundleId ? { bundleId: opts.bundleId } : { packageName: opts.packageName };
+  };
+  session.command("launch-app").description("Launch an installed app").argument("<session-id>", "Session ID").option("--bundle-id <id>", "iOS bundle ID").option("--package-name <name>", "Android package name").option("--activity <name>", "Android activity to launch").action(run("session-launch-app", async (http, sessionId, opts) => {
+    if (opts.activity && !opts.packageName) throw new PncliError("--activity requires --package-name.", 1);
+    const body = { ...appIdentity(opts), ...opts.activity ? { activityName: opts.activity } : {} };
+    await http.saucelabs(deviceAction(sessionId, "launchApp"), { method: "POST", body });
+    return { sessionId, ...body, launched: true };
+  }));
+  session.command("uninstall-app").description("Uninstall an app").argument("<session-id>", "Session ID").option("--bundle-id <id>", "iOS bundle ID").option("--package-name <name>", "Android package name").action(run("session-uninstall-app", async (http, sessionId, opts) => {
+    const body = appIdentity(opts);
+    await http.saucelabs(deviceAction(sessionId, "uninstallApp"), { method: "POST", body });
+    return { sessionId, ...body, uninstalled: true };
+  }));
+  session.command("settings").description("Change device settings: orientation (both), locale and animations (Android only)").argument("<session-id>", "Session ID").option("--orientation <orientation>", "Screen orientation: portrait or landscape").option("--locale <locale>", "Locale, for example en_US (Android only)").option("--animations <on|off>", "Enable or disable system animations (Android only)").action(run("session-settings", async (http, sessionId, opts) => {
+    const body = {};
+    const orientation = parseChoice(opts.orientation, ORIENTATIONS, "--orientation");
+    if (orientation) body["orientation"] = orientation;
+    if (opts.locale) body["locale"] = opts.locale;
+    const animations = parseChoice(opts.animations, ["on", "off"], "--animations");
+    if (animations) body["animations"] = animations === "on";
+    await http.saucelabs(deviceAction(sessionId, "applySettings"), {
+      method: "POST",
+      body: requireBody(body, "Pass at least one of --orientation, --locale, --animations.")
+    });
+    return { sessionId, applied: body };
+  }));
+  session.command("start-test").description("Start recording a test (a job) inside the session").argument("<session-id>", "Session ID").option("--name <name>", "Test name").option("--build <build>", "Build name").option("--tags <tags>", "Comma-separated tags", collectList).option("--video", "Record video").option("--device-logs", "Capture device logs").option("--network-capture", "Capture network traffic").option("--screenshots", "Capture screenshots").option("--appium-logs", "Capture Appium logs").action(run("session-start-test", (http, sessionId, opts) => {
+    const body = {};
+    if (opts.name) body["testName"] = opts.name;
+    if (opts.build) body["build"] = opts.build;
+    if (opts.tags) body["tags"] = opts.tags;
+    const artifacts = {
+      video: Boolean(opts.video),
+      deviceLogs: Boolean(opts.deviceLogs),
+      networkCapture: Boolean(opts.networkCapture),
+      screenshots: Boolean(opts.screenshots),
+      appiumLogs: Boolean(opts.appiumLogs)
+    };
+    if (Object.values(artifacts).some(Boolean)) body["artifacts"] = artifacts;
+    return http.saucelabs(`${sessionPath(sessionId)}/startTest`, { method: "POST", body });
+  }));
+  session.command("end-test").description("End the active test in the session, optionally recording its result").argument("<session-id>", "Session ID").option("--passed", "Mark the test as passed").option("--failed", "Mark the test as failed").action(run("session-end-test", (http, sessionId, opts) => {
+    const passed = passedFlag(opts);
+    return http.saucelabs(`${sessionPath(sessionId)}/endTest`, {
+      method: "POST",
+      body: passed === void 0 ? {} : { status: passed ? "passed" : "failed" }
+    });
+  }));
+  session.command("tests").description("List the tests recorded in a session, with links to each job").argument("<session-id>", "Session ID").action(run("session-tests", (http, sessionId) => http.saucelabs(`${sessionPath(sessionId)}/tests`)));
+  session.command("network-profiles").description("List the network throttling profiles available to a session").argument("<session-id>", "Session ID").action(run("session-network-profiles", (http, sessionId) => http.saucelabs(`${sessionPath(sessionId)}/network/profiles`)));
+  session.command("network").description("Throttle the device network with a named profile or explicit conditions, or --reset to clear").argument("<session-id>", "Session ID").option("--profile <name>", "Named profile from network-profiles, for example 4G-fast").option("--download <kbps>", "Download speed in kbps (0-50000)").option("--upload <kbps>", "Upload speed in kbps (0-50000)").option("--latency <ms>", "Added latency in ms (0-3000)").option("--loss <percent>", "Packet loss percent (0-100)").option("--reset", "Remove all throttling").action(run("session-network", async (http, sessionId, opts) => {
+    const conditions = {};
+    const set = (key, value, flag, max) => {
+      const n = parseIntOption(value, flag);
+      if (n === void 0) return;
+      if (n > max) throw new PncliError(`${flag} must be between 0 and ${max}.`, 1);
+      conditions[key] = n;
+    };
+    set("downloadSpeed", opts.download, "--download", 5e4);
+    set("uploadSpeed", opts.upload, "--upload", 5e4);
+    set("latency", opts.latency, "--latency", 3e3);
+    set("loss", opts.loss, "--loss", 100);
+    const modes = [Boolean(opts.reset), Boolean(opts.profile), Object.keys(conditions).length > 0].filter(Boolean).length;
+    if (modes !== 1) {
+      throw new PncliError("Pass exactly one of --profile, --reset, or explicit conditions (--download/--upload/--latency/--loss).", 1);
+    }
+    if (opts.reset) {
+      await http.saucelabs(`${sessionPath(sessionId)}/network/condition`, { method: "DELETE" });
+      return { sessionId, reset: true };
+    }
+    if (opts.profile) {
+      return http.saucelabs(`${sessionPath(sessionId)}/network/profile`, { method: "POST", body: { networkProfile: opts.profile } });
+    }
+    return http.saucelabs(`${sessionPath(sessionId)}/network/condition`, { method: "POST", body: { networkConditions: conditions } });
+  }));
+  session.command("appium").description("Get the session's Appium server URL, or --start one").argument("<session-id>", "Session ID").option("--start", "Start an Appium server for the session").option("--appium-version <version>", "Appium version to start (see appium-versions)").action(run("session-appium", (http, sessionId, opts) => {
+    if (opts.appiumVersion && !opts.start) throw new PncliError("--appium-version requires --start.", 1);
+    if (!opts.start) return http.saucelabs(`${sessionPath(sessionId)}/appiumserver`);
+    return http.saucelabs(`${sessionPath(sessionId)}/appiumserver`, {
+      method: "POST",
+      body: opts.appiumVersion ? { appiumVersion: opts.appiumVersion } : {}
+    });
+  }));
+  sauce.command("appium-versions").description("Appium versions available for real-device sessions, with end-of-life dates").action(run("appium-versions", (http) => http.saucelabs(`${RDA}/appium/versions`)));
+  const tunnel = sauce.command("tunnel").description("Sauce Connect tunnels");
+  tunnel.command("list").description("List your tunnels with full details").option("--all", "Include tunnels shared with you").action(run("tunnel-list", async (http, opts) => {
+    const data = await http.saucelabs(`/rest/v1/${id(http.saucelabsUsername())}/tunnels`, {
+      params: { full: true, all: opts.all ? true : void 0 }
+    });
+    return { count: countOf(data), tunnels: data };
+  }));
+  tunnel.command("get").description("Get one tunnel").argument("<tunnel-id>", "Tunnel ID").action(run("tunnel-get", (http, tunnelId) => http.saucelabs(`/rest/v1/${id(http.saucelabsUsername())}/tunnels/${id(tunnelId)}`)));
+  tunnel.command("jobs").description("Number of jobs currently running through a tunnel").argument("<tunnel-id>", "Tunnel ID").action(run("tunnel-jobs", (http, tunnelId) => http.saucelabs(`/rest/v1/${id(http.saucelabsUsername())}/tunnels/${id(tunnelId)}/num_jobs`)));
+  tunnel.command("stop").description("Shut down a tunnel").argument("<tunnel-id>", "Tunnel ID").action(run("tunnel-stop", (http, tunnelId) => http.saucelabs(`/rest/v1/${id(http.saucelabsUsername())}/tunnels/${id(tunnelId)}`, { method: "DELETE" })));
+  const storage = sauce.command("storage").description("App storage metadata (no upload or download)");
+  storage.command("files").description("List uploaded app files").option("--query <text>", "Search file names and app metadata").option("--kind <kind>", "App kind: android or ios").option("--page <n>", "Page number (starts at 1)").option("--per-page <n>", "Results per page (max 100)").action(run("storage-files", (http, opts) => http.saucelabs("/v1/storage/files", {
+    params: {
+      q: opts.query,
+      kind: parseChoice(opts.kind, STORAGE_KINDS, "--kind"),
+      page: parseIntOption(opts.page, "--page"),
+      per_page: parseIntOption(opts.perPage, "--per-page")
+    }
+  })));
+  storage.command("groups").description("List app groups (all versions of one app)").option("--query <text>", "Search group names").option("--kind <kind>", "App kind: android or ios").option("--page <n>", "Page number (starts at 1)").option("--per-page <n>", "Results per page (max 100)").action(run("storage-groups", (http, opts) => http.saucelabs("/v1/storage/groups", {
+    params: {
+      q: opts.query,
+      kind: parseChoice(opts.kind, STORAGE_KINDS, "--kind"),
+      page: parseIntOption(opts.page, "--page"),
+      per_page: parseIntOption(opts.perPage, "--per-page")
+    }
+  })));
+  const team = sauce.command("team").description("Teams in your organization");
+  team.command("list").description("List teams").option("--name <prefix>", "Team name prefix").action(run("team-list", (http, opts) => http.saucelabs(`${TEAM_MGMT}/teams/`, { params: { name: opts.name } })));
+  team.command("get").description("Get one team and its settings").argument("<team-id>", "Team ID").action(run("team-get", (http, teamId) => http.saucelabs(`${TEAM_MGMT}/teams/${id(teamId)}/`)));
+  team.command("members").description("List a team's members").argument("<team-id>", "Team ID").action(run("team-members", (http, teamId) => http.saucelabs(`${TEAM_MGMT}/teams/${id(teamId)}/members/`)));
+  sauce.command("users").description("Look up users in your organization").option("--username <username>", "Exact username").option("--phrase <text>", "Search username, name, and email").option("--limit <n>", "Maximum results (default 20, max 100)").option("--offset <n>", "Number of results to skip").action(run("users", (http, opts) => http.saucelabs(`${TEAM_MGMT}/users/`, {
+    params: {
+      username: opts.username,
+      phrase: opts.phrase,
+      limit: parseIntOption(opts.limit, "--limit"),
+      offset: parseIntOption(opts.offset, "--offset")
+    }
+  })));
+}
+var TERMINAL_SESSION_STATES = /* @__PURE__ */ new Set(["CLOSING", "CLOSED", "ERRORED"]);
+async function waitForSession(http, sessionId, timeoutSeconds, pollMs = 5e3) {
+  const deadline = Date.now() + timeoutSeconds * 1e3;
+  for (; ; ) {
+    const current = await http.saucelabs(`${RDA}/sessions/${id(sessionId)}`);
+    if (current.state === "ACTIVE") return current;
+    if (TERMINAL_SESSION_STATES.has(current.state)) {
+      throw new PncliError(`Session ${sessionId} ended in state ${current.state} before becoming ACTIVE.`, 1);
+    }
+    if (Date.now() + pollMs > deadline) {
+      throw new PncliError(
+        `Session ${sessionId} still ${current.state} after ${timeoutSeconds}s. It keeps starting in the background \u2014 check it with: pncli saucelabs session get ${sessionId}`,
+        1
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollMs));
+  }
+}
+
 // src/services/config/check.ts
 async function runCredentialChecks(cfg, http) {
   const results = {};
@@ -7602,6 +8020,20 @@ async function runCredentialChecks(cfg, http) {
       results.alation = categorize(err);
     }
   }
+  if (!cfg.saucelabs.accessKey) {
+    results.saucelabs = { status: "blank", message: "not configured" };
+  } else if (!cfg.saucelabs.baseUrl) {
+    results.saucelabs = { status: "error", message: "baseUrl not configured" };
+  } else if (!cfg.saucelabs.username) {
+    results.saucelabs = { status: "error", message: "username not configured" };
+  } else {
+    try {
+      await verifySauceLabsCredentials(http, 1e4);
+      results.saucelabs = { status: "valid", message: "ok" };
+    } catch (err) {
+      results.saucelabs = categorize(err);
+    }
+  }
   return results;
 }
 
@@ -10509,6 +10941,20 @@ function registerConfigCommands(program2) {
       } else {
         results.alation = { ok: null, message: "not configured" };
       }
+      if (cfg.saucelabs.accessKey && !cfg.saucelabs.baseUrl) {
+        results.saucelabs = { ok: false, message: "baseUrl not configured" };
+      } else if (cfg.saucelabs.accessKey && !cfg.saucelabs.username) {
+        results.saucelabs = { ok: false, message: "username not configured" };
+      } else if (cfg.saucelabs.accessKey) {
+        try {
+          await verifySauceLabsCredentials(http);
+          results.saucelabs = { ok: true, message: "connected" };
+        } catch (err) {
+          results.saucelabs = { ok: false, message: err instanceof Error ? err.message : String(err) };
+        }
+      } else {
+        results.saucelabs = { ok: null, message: "not configured" };
+      }
       success(results, "config", "test", start);
     } catch (err) {
       fail(err, "config", "test", start);
@@ -10551,7 +10997,8 @@ function registerConfigCommands(program2) {
         "logscale",
         "splitio",
         "figma",
-        "alation"
+        "alation",
+        "saucelabs"
       ];
       if (cmdOpts.output === "table") {
         const labelWidth = Math.max(14, ...allServices.map((s) => s.length + 2));
@@ -11208,6 +11655,48 @@ async function initGlobalConfig(start) {
       }
     }
   }
+  process.stderr.write("\n\u2500\u2500 Sauce Labs \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+  const useSaucelabs = await confirm({
+    message: "Configure Sauce Labs for jobs, builds, and real-device access?",
+    default: false
+  });
+  let saucelabsBaseUrl = "";
+  let saucelabsUsername = "";
+  let saucelabsAccessKey = "";
+  if (useSaucelabs) {
+    process.stderr.write("  Find your username and access key in Sauce Labs under Account \u2192 User Settings.\n");
+    process.stderr.write("  The API host depends on your data center: https://api.us-west-1.saucelabs.com,\n");
+    process.stderr.write("  https://api.eu-central-1.saucelabs.com, or https://api.us-east-4.saucelabs.com.\n");
+    saucelabsBaseUrl = await input2({
+      message: "Sauce Labs API base URL:",
+      validate: (v) => v.trim().length > 0 || "Required"
+    });
+    saucelabsUsername = await input2({
+      message: "Sauce Labs username:",
+      validate: (v) => v.trim().length > 0 || "Required"
+    });
+    saucelabsAccessKey = await password2({
+      message: "Sauce Labs access key:"
+    });
+    if (saucelabsBaseUrl && saucelabsUsername && saucelabsAccessKey) {
+      process.stderr.write("\n  Verifying connection...\n");
+      try {
+        const tempConfig = {
+          ...loadConfig(),
+          saucelabs: {
+            baseUrl: normalizeBaseUrl(saucelabsBaseUrl),
+            username: saucelabsUsername.trim(),
+            accessKey: saucelabsAccessKey
+          }
+        };
+        await verifySauceLabsCredentials(createHttpClient(tempConfig));
+        process.stderr.write("  Connected.\n");
+      } catch (err) {
+        warn(`Could not connect to Sauce Labs: ${err instanceof Error ? err.message : String(err)}`);
+        warn("Config will be saved anyway. Check your data center URL, username, and access key and re-run pncli config init or pncli config test.");
+      }
+    }
+  }
   process.stderr.write("\n\u2500\u2500 Defaults \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
   const jiraProject = await input2({
     message: "Default Jira project key (optional):",
@@ -11377,6 +11866,13 @@ async function initGlobalConfig(start) {
         userId: alationUserId.trim() || void 0
       }
     } : {},
+    ...useSaucelabs && saucelabsBaseUrl ? {
+      saucelabs: {
+        baseUrl: normalizeBaseUrl(saucelabsBaseUrl),
+        username: saucelabsUsername.trim() || void 0,
+        accessKey: saucelabsAccessKey || void 0
+      }
+    } : {},
     defaults: {
       jira: {
         project: jiraProject || void 0
@@ -11993,9 +12489,9 @@ var AdoBuildClient = class {
       );
     });
   }
-  async getDefinition(collection, project, id) {
+  async getDefinition(collection, project, id2) {
     return this.http.ado(
-      `/${encodeURIComponent(collection)}/${encodeURIComponent(project)}/_apis/build/definitions/${id}?api-version=${API8}`
+      `/${encodeURIComponent(collection)}/${encodeURIComponent(project)}/_apis/build/definitions/${id2}?api-version=${API8}`
     );
   }
   // ── Builds (runs) ─────────────────────────────────────────────────
@@ -12605,7 +13101,7 @@ function registerAdoRepoCommands(ado) {
     const start = Date.now();
     try {
       const { collection, project, repo: repo2, gitClient } = getAdoContext(ado, true);
-      const reviewers = opts.reviewers ? opts.reviewers.split(",").map((id) => ({ id: id.trim() })) : [];
+      const reviewers = opts.reviewers ? opts.reviewers.split(",").map((id2) => ({ id: id2.trim() })) : [];
       const data = await gitClient.createPR(collection, project, repo2, {
         title: opts.title,
         description: opts.description,
@@ -12623,7 +13119,7 @@ function registerAdoRepoCommands(ado) {
     const start = Date.now();
     try {
       const { collection, project, repo: repo2, gitClient } = getAdoContext(ado, true);
-      const reviewers = opts.reviewers ? opts.reviewers.split(",").map((id) => ({ id: id.trim() })) : void 0;
+      const reviewers = opts.reviewers ? opts.reviewers.split(",").map((id2) => ({ id: id2.trim() })) : void 0;
       const body = {};
       if (opts.title) body.title = opts.title;
       if (opts.description !== void 0) body.description = opts.description;
@@ -12810,11 +13306,11 @@ function registerAdoRepoCommands(ado) {
       const start = Date.now();
       try {
         const globalOpts = ado.optsWithGlobals();
-        const { loadConfig: lc } = await import("./config-OH2O5E3P.js");
+        const { loadConfig: lc } = await import("./config-5LC7ZTEP.js");
         const config = lc({ configPath: globalOpts.config });
         const { collection, project, repo: repo2, gitClient } = getAdoContext(ado, true);
         const { AdoCoreClient: AdoCoreClient2 } = await import("./core-SWYVXOQ4.js");
-        const { createHttpClient: createHttpClient2 } = await import("./http-V7PZD7LE.js");
+        const { createHttpClient: createHttpClient2 } = await import("./http-DJSGEGD6.js");
         const http = createHttpClient2(config, Boolean(globalOpts.dryRun));
         const coreClient = new AdoCoreClient2(http);
         const me = await coreClient.getConnectionData(collection);
@@ -13489,8 +13985,8 @@ var CheckmarxClient = class {
     }
     return projects;
   }
-  async getProject(id) {
-    return this.http.checkmarx(`projects/${id}`);
+  async getProject(id2) {
+    return this.http.checkmarx(`projects/${id2}`);
   }
   async listScans(opts = {}) {
     const params = { limit: opts.last ?? 100 };
@@ -13503,8 +13999,8 @@ var CheckmarxClient = class {
     }
     return scans;
   }
-  async getScan(id) {
-    return this.http.checkmarx(`scans/${id}`);
+  async getScan(id2) {
+    return this.http.checkmarx(`scans/${id2}`);
   }
   async getScanResultsStatistics(scanId) {
     return this.http.checkmarx("results/summary", {
@@ -13820,7 +14316,7 @@ function resolveCluster(config, env, instance) {
   }
   return { baseUrl: config.openshift.baseUrl, token: config.openshift.token };
 }
-function getHttp(oc) {
+function getHttp2(oc) {
   const opts = oc.optsWithGlobals();
   const config = loadConfig({ configPath: opts.config });
   const cluster = resolveCluster(config, opts.env, opts.instance);
@@ -13896,7 +14392,7 @@ function registerOpenShiftCommands(program2) {
   oc.command("pods").description("List pod health summary for a namespace \u2014 pre-processed for LLM analysis. Use --raw to return the full unmodified Kubernetes pod objects.").requiredOption("--namespace <ns>", "Kubernetes namespace").option("--label-selector <selector>", "Label selector (e.g. app=my-app)").option("--raw", "Return full Kubernetes pod objects without summarization (includes env vars, images, node name, annotations, resources, etc.)", false).action(async (opts) => {
     const start = Date.now();
     try {
-      const http = getHttp(oc);
+      const http = getHttp2(oc);
       const params = {};
       if (opts.labelSelector) params["labelSelector"] = opts.labelSelector;
       const podList = await http.openshift(
@@ -14005,7 +14501,7 @@ function registerOpenShiftCommands(program2) {
   oc.command("events").description("List Warning events for a namespace \u2014 pre-filtered for LLM analysis").requiredOption("--namespace <ns>", "Kubernetes namespace").option("--field-selector <selector>", "Additional field selector (e.g. involvedObject.name=my-pod)").option("--all", "Include Normal events in addition to Warning events", false).action(async (opts) => {
     const start = Date.now();
     try {
-      const http = getHttp(oc);
+      const http = getHttp2(oc);
       const params = {};
       const selectors = [];
       if (!opts.all) selectors.push("type=Warning");
@@ -14039,7 +14535,7 @@ function registerOpenShiftCommands(program2) {
   oc.command("logs").description("Get recent log lines from a pod container").requiredOption("--namespace <ns>", "Kubernetes namespace").requiredOption("--pod <name>", "Pod name").option("--container <name>", "Container name (defaults to first container)").option("--lines <n>", "Number of most-recent lines to return", "100").option("--previous", "Return logs from the previous container instance", false).action(async (opts) => {
     const start = Date.now();
     try {
-      const http = getHttp(oc);
+      const http = getHttp2(oc);
       const lines = opts.lines ? parseInt(opts.lines, 10) : 100;
       const logText = await http.openshiftText(
         `/api/v1/namespaces/${encodeURIComponent(opts.namespace)}/pods/${encodeURIComponent(opts.pod)}/log`,
@@ -14071,7 +14567,7 @@ function registerOpenShiftCommands(program2) {
   oc.command("pod-metrics").description("Get CPU and memory usage for pods in a namespace (requires metrics-server)").requiredOption("--namespace <ns>", "Kubernetes namespace").action(async (opts) => {
     const start = Date.now();
     try {
-      const http = getHttp(oc);
+      const http = getHttp2(oc);
       const metricsList = await http.openshift(
         `/apis/metrics.k8s.io/v1beta1/namespaces/${encodeURIComponent(opts.namespace)}/pods`
       );
@@ -14091,7 +14587,7 @@ function registerOpenShiftCommands(program2) {
   oc.command("resource-usage").description("Combined CPU/memory usage, limits, and requests for all pods in a namespace \u2014 all values normalized to millicores (m) and mebibytes (Mi). Requires metrics-server. Use --csv to emit a spreadsheet-friendly CSV.").requiredOption("--namespace <ns>", "Kubernetes namespace").option("--label-selector <selector>", "Label selector (e.g. app=my-app)").option("--csv", "Output as CSV instead of JSON (suitable for Excel)", false).action(async (opts) => {
     const start = Date.now();
     try {
-      const http = getHttp(oc);
+      const http = getHttp2(oc);
       const nsEncoded = encodeURIComponent(opts.namespace);
       const podParams = {};
       if (opts.labelSelector) podParams["labelSelector"] = opts.labelSelector;
@@ -14156,7 +14652,7 @@ function registerOpenShiftCommands(program2) {
 }
 
 // src/services/dynatrace/commands.ts
-function getHttp2(program2, envName) {
+function getHttp3(program2, envName) {
   const opts = program2.optsWithGlobals();
   const cfg = loadConfig({ configPath: opts.config });
   if (envName) {
@@ -14280,7 +14776,7 @@ function registerDynatraceCommands(program2) {
     const start = Date.now();
     try {
       const envName = dynatrace.opts().env;
-      const data = await listEntities(getHttp2(program2, envName), opts.selector, opts);
+      const data = await listEntities(getHttp3(program2, envName), opts.selector, opts);
       success({ totalCount: data.totalCount, entities: data.items }, "dynatrace", "entities list", start);
     } catch (err) {
       fail(err, "dynatrace", "entities list", start);
@@ -14290,7 +14786,7 @@ function registerDynatraceCommands(program2) {
     const start = Date.now();
     try {
       const envName = dynatrace.opts().env;
-      const data = await getHttp2(program2, envName).dynatrace(
+      const data = await getHttp3(program2, envName).dynatrace(
         `/api/v2/entities/${encodeURIComponent(opts.id)}`,
         { params: { from: opts.from, to: opts.to, fields: opts.fields } }
       );
@@ -14303,7 +14799,7 @@ function registerDynatraceCommands(program2) {
     const start = Date.now();
     try {
       const envName = dynatrace.opts().env;
-      const data = await listEntities(getHttp2(program2, envName), 'type("SERVICE")', opts);
+      const data = await listEntities(getHttp3(program2, envName), 'type("SERVICE")', opts);
       success({ totalCount: data.totalCount, services: data.items }, "dynatrace", "services", start);
     } catch (err) {
       fail(err, "dynatrace", "services", start);
@@ -14314,7 +14810,7 @@ function registerDynatraceCommands(program2) {
     try {
       const envName = dynatrace.opts().env;
       const selector = 'type("CLOUD_APPLICATION")';
-      const data = await listEntities(getHttp2(program2, envName), selector, opts);
+      const data = await listEntities(getHttp3(program2, envName), selector, opts);
       success({ totalCount: data.totalCount, workloads: data.items }, "dynatrace", "workloads", start);
     } catch (err) {
       fail(err, "dynatrace", "workloads", start);
@@ -14326,7 +14822,7 @@ function registerDynatraceCommands(program2) {
     try {
       const envName = dynatrace.opts().env;
       const data = await allPages(async (nextPageKey) => {
-        const page = await getHttp2(program2, envName).dynatrace("/api/v2/problems", {
+        const page = await getHttp3(program2, envName).dynatrace("/api/v2/problems", {
           params: nextPageKey ? { nextPageKey } : {
             from: opts.from ?? "now-2h",
             to: opts.to ?? "now",
@@ -14346,7 +14842,7 @@ function registerDynatraceCommands(program2) {
     const start = Date.now();
     try {
       const envName = dynatrace.opts().env;
-      const data = await getHttp2(program2, envName).dynatrace(
+      const data = await getHttp3(program2, envName).dynatrace(
         `/api/v2/problems/${encodeURIComponent(opts.id)}`,
         { params: { fields: opts.fields } }
       );
@@ -14359,7 +14855,7 @@ function registerDynatraceCommands(program2) {
     const start = Date.now();
     try {
       const envName = dynatrace.opts().env;
-      const result = await runTraceQuery(getHttp2(program2, envName), opts.id);
+      const result = await runTraceQuery(getHttp3(program2, envName), opts.id);
       success(result, "dynatrace", "trace", start);
     } catch (err) {
       fail(err, "dynatrace", "trace", start);
@@ -14368,7 +14864,7 @@ function registerDynatraceCommands(program2) {
 }
 
 // src/services/logscale/commands.ts
-function getHttp3(program2) {
+function getHttp4(program2) {
   const opts = program2.optsWithGlobals();
   return createHttpClient(
     loadConfig({ configPath: opts.config }),
@@ -14381,7 +14877,7 @@ function registerLogscaleCommands(program2) {
   repositories.command("list").description("List available repositories").action(async () => {
     const start = Date.now();
     try {
-      const data = await getHttp3(program2).logscale("/api/v1/repositories");
+      const data = await getHttp4(program2).logscale("/api/v1/repositories");
       success({ count: data.length, repositories: data }, "logscale", "repositories list", start);
     } catch (err) {
       fail(err, "logscale", "repositories list", start);
@@ -14398,7 +14894,7 @@ function registerLogscaleCommands(program2) {
         showQueryEventDistribution: false,
         isLive: false
       };
-      const data = await getHttp3(program2).logscale(
+      const data = await getHttp4(program2).logscale(
         `/api/v1/repositories/${encodeURIComponent(opts.repository)}/query`,
         {
           method: "POST",
@@ -14429,7 +14925,7 @@ function registerLogscaleCommands(program2) {
 // src/services/splitio/commands.ts
 import fs11 from "fs";
 import confirm2 from "@inquirer/confirm";
-function getHttp4(program2) {
+function getHttp5(program2) {
   const opts = program2.optsWithGlobals();
   return createHttpClient(
     loadConfig({ configPath: opts.config }),
@@ -14464,7 +14960,7 @@ function buildCrBase(opts) {
     crNumber: opts.changeNumber
   };
   if (opts.approvers) {
-    base["approvers"] = opts.approvers.split(",").map((s) => s.trim()).filter(Boolean).map((id) => ({ id }));
+    base["approvers"] = opts.approvers.split(",").map((s) => s.trim()).filter(Boolean).map((id2) => ({ id: id2 }));
   }
   return base;
 }
@@ -14474,7 +14970,7 @@ function registerSplitioCommands(program2) {
   workspaces.command("list").description("List all Split.IO workspaces").action(async () => {
     const start = Date.now();
     try {
-      const http = getHttp4(program2);
+      const http = getHttp5(program2);
       const data = await http.splitio("/internal/api/v2/workspaces");
       success(
         { count: data.objects.length, workspaces: data.objects },
@@ -14490,7 +14986,7 @@ function registerSplitioCommands(program2) {
   environments.command("list").description("List environments in a workspace").requiredOption("--workspace <id>", "Workspace ID").action(async (opts) => {
     const start = Date.now();
     try {
-      const http = getHttp4(program2);
+      const http = getHttp5(program2);
       const data = await http.splitio(
         `/internal/api/v2/environments/ws/${encodeURIComponent(opts.workspace)}`
       );
@@ -14508,7 +15004,7 @@ function registerSplitioCommands(program2) {
   flags.command("list").description("List feature flags in a workspace").requiredOption("--workspace <id>", "Workspace ID").option("--limit <n>", "Maximum number of flags to return", "50").option("--offset <n>", "Pagination offset", "0").option("--flag-set <name>", "Filter by flag set name").action(async (opts) => {
     const start = Date.now();
     try {
-      const http = getHttp4(program2);
+      const http = getHttp5(program2);
       const params = {
         limit: parseInt(opts.limit, 10),
         offset: parseInt(opts.offset, 10)
@@ -14531,7 +15027,7 @@ function registerSplitioCommands(program2) {
   flags.command("get").description("Get a flag definition").requiredOption("--workspace <id>", "Workspace ID").requiredOption("--flag <name>", "Feature flag name").option("--environment <id>", "Environment ID \u2014 include targeting rules for this environment").action(async (opts) => {
     const start = Date.now();
     try {
-      const http = getHttp4(program2);
+      const http = getHttp5(program2);
       if (opts.environment) {
         const data = await http.splitio(
           `/internal/api/v2/splits/ws/${encodeURIComponent(opts.workspace)}/name/${encodeURIComponent(opts.flag)}/environment/${encodeURIComponent(opts.environment)}`
@@ -14553,7 +15049,7 @@ function registerSplitioCommands(program2) {
       if (!opts.inputFile) throw new PncliError("--input-file is required for flags update");
       const definition = loadInputFile(opts.inputFile);
       await confirmWrite(opts, `UPDATE ${opts.flag} in ${opts.environment}`);
-      const http = getHttp4(program2);
+      const http = getHttp5(program2);
       const body = {
         ...buildCrBase(opts),
         operationType: "UPDATE_SPLIT_DEFINITION",
@@ -14579,7 +15075,7 @@ function registerSplitioCommands(program2) {
       if (!opts.treatment && !opts.weights) {
         throw new PncliError("Either --treatment or --weights must be specified");
       }
-      const http = getHttp4(program2);
+      const http = getHttp5(program2);
       const current = await http.splitio(
         `/internal/api/v2/splits/ws/${encodeURIComponent(opts.workspace)}/name/${encodeURIComponent(opts.flag)}/environment/${encodeURIComponent(opts.environment)}`
       );
@@ -14617,7 +15113,7 @@ function registerSplitioCommands(program2) {
   flags.command("set-default").description("Update the fallback default rule for traffic matching no targeting rule").requiredOption("--workspace <id>", "Workspace ID").requiredOption("--flag <name>", "Feature flag name").requiredOption("--environment <id>", "Environment ID").requiredOption("--treatment <name>", "Treatment to assign as the default").requiredOption("--mnemonic <text>", "Short Change Request title (mnemonic)").requiredOption("--description <text>", "Change Request description").requiredOption("--change-number <CHG>", "Change request number (e.g. CHG0001234)").option("--approvers <ids>", "Comma-separated Split user IDs required to approve this CR").option("--yes", "Skip interactive confirmation prompt").action(async (opts) => {
     const start = Date.now();
     try {
-      const http = getHttp4(program2);
+      const http = getHttp5(program2);
       const current = await http.splitio(
         `/internal/api/v2/splits/ws/${encodeURIComponent(opts.workspace)}/name/${encodeURIComponent(opts.flag)}/environment/${encodeURIComponent(opts.environment)}`
       );
@@ -14650,7 +15146,7 @@ function registerSplitioCommands(program2) {
       const enable = opts.enabled.toLowerCase() !== "false" && opts.enabled !== "0";
       const opType = enable ? "RESTORE_SPLIT" : "KILL_SPLIT";
       await confirmWrite(opts, `${opType} ${opts.flag} in ${opts.environment}`);
-      const http = getHttp4(program2);
+      const http = getHttp5(program2);
       const body = {
         ...buildCrBase(opts),
         operationType: opType,
@@ -14673,7 +15169,7 @@ function registerSplitioCommands(program2) {
       const entries = loadInputFile(opts.inputFile);
       if (!Array.isArray(entries)) throw new PncliError("Input file must be a JSON array of {flag, enabled} objects");
       await confirmWrite(opts, `BATCH_TOGGLE ${entries.length} flags in ${opts.environment}`);
-      const http = getHttp4(program2);
+      const http = getHttp5(program2);
       const results = [];
       for (const entry of entries) {
         try {
@@ -14707,7 +15203,7 @@ function registerSplitioCommands(program2) {
     const start = Date.now();
     try {
       await confirmWrite(opts, `KILL ${opts.flag} in ${opts.environment}`);
-      const http = getHttp4(program2);
+      const http = getHttp5(program2);
       const body = {
         ...buildCrBase(opts),
         operationType: "KILL_SPLIT",
@@ -14727,7 +15223,7 @@ function registerSplitioCommands(program2) {
     const start = Date.now();
     try {
       await confirmWrite(opts, `RESTORE ${opts.flag} in ${opts.environment}`);
-      const http = getHttp4(program2);
+      const http = getHttp5(program2);
       const body = {
         ...buildCrBase(opts),
         operationType: "RESTORE_SPLIT",
@@ -14747,7 +15243,7 @@ function registerSplitioCommands(program2) {
     const start = Date.now();
     try {
       await confirmWrite(opts, `ARCHIVE ${opts.flag}`);
-      const http = getHttp4(program2);
+      const http = getHttp5(program2);
       const body = {
         ...buildCrBase(opts),
         operationType: "ARCHIVE_SPLIT",
@@ -14767,7 +15263,7 @@ function registerSplitioCommands(program2) {
   changeRequests.command("list").description("List Change Requests for a workspace").requiredOption("--workspace <id>", "Workspace ID").option("--environment <id>", "Filter by environment ID").option("--status <status>", "Filter by status (REQUESTED, APPROVED, REJECTED, PUBLISHED)").option("--limit <n>", "Maximum number of results", "25").option("--offset <n>", "Pagination offset", "0").action(async (opts) => {
     const start = Date.now();
     try {
-      const http = getHttp4(program2);
+      const http = getHttp5(program2);
       const params = {
         limit: parseInt(opts.limit, 10),
         offset: parseInt(opts.offset, 10)
@@ -14791,7 +15287,7 @@ function registerSplitioCommands(program2) {
   changeRequests.command("get").description("Get a Change Request by ID").requiredOption("--id <id>", "Change Request ID").action(async (opts) => {
     const start = Date.now();
     try {
-      const http = getHttp4(program2);
+      const http = getHttp5(program2);
       const data = await http.splitio(
         `/internal/api/v2/changeRequests/${encodeURIComponent(opts.id)}`
       );
@@ -14843,7 +15339,7 @@ function findNodeIdInUrl(url) {
   if (!new URL(url).searchParams.has("node-id")) return void 0;
   return parseNodeId(url);
 }
-function getHttp5(program2) {
+function getHttp6(program2) {
   const opts = program2.optsWithGlobals();
   return createHttpClient(
     loadConfig({ configPath: opts.config }),
@@ -14859,7 +15355,7 @@ function registerFigmaCommands(program2) {
       const fileKey = parseFileKey(fileKeyOrUrl);
       const nodeId = opts.nodeId ? parseNodeId(opts.nodeId) : isUrl(fileKeyOrUrl) ? findNodeIdInUrl(fileKeyOrUrl) : void 0;
       if (nodeId) {
-        const data2 = await getHttp5(program2).figma(
+        const data2 = await getHttp6(program2).figma(
           `/v1/files/${encodeURIComponent(fileKey)}/nodes`,
           { params: { ids: nodeId } }
         );
@@ -14888,7 +15384,7 @@ function registerFigmaCommands(program2) {
       if (!opts.document) {
         params["depth"] = 1;
       }
-      const data = await getHttp5(program2).figma(`/v1/files/${encodeURIComponent(fileKey)}`, { params });
+      const data = await getHttp6(program2).figma(`/v1/files/${encodeURIComponent(fileKey)}`, { params });
       success2(
         {
           fileKey,
@@ -14918,7 +15414,7 @@ function registerFigmaCommands(program2) {
       const fileKey = parseFileKey(fileKeyOrUrl);
       const params = {};
       if (opts.asOf) params["as_of"] = opts.asOf;
-      const data = await getHttp5(program2).figma(`/v1/files/${encodeURIComponent(fileKey)}/comments`, { params });
+      const data = await getHttp6(program2).figma(`/v1/files/${encodeURIComponent(fileKey)}/comments`, { params });
       success2(
         { fileKey, count: data.comments.length, comments: data.comments },
         "figma",
@@ -14934,7 +15430,7 @@ function registerFigmaCommands(program2) {
     const { success: success2, fail: fail2 } = await import("./output-HDUIIXUI.js");
     try {
       const fileKey = parseFileKey(fileKeyOrUrl);
-      const data = await getHttp5(program2).figma(`/v1/files/${encodeURIComponent(fileKey)}/versions`);
+      const data = await getHttp6(program2).figma(`/v1/files/${encodeURIComponent(fileKey)}/versions`);
       success2(
         { fileKey, count: data.versions.length, versions: data.versions },
         "figma",
@@ -14949,7 +15445,7 @@ function registerFigmaCommands(program2) {
     const start = Date.now();
     const { success: success2, fail: fail2 } = await import("./output-HDUIIXUI.js");
     try {
-      const data = await getHttp5(program2).figma(`/v1/projects/${encodeURIComponent(projectId)}/files`);
+      const data = await getHttp6(program2).figma(`/v1/projects/${encodeURIComponent(projectId)}/files`);
       success2(
         { projectId, count: data.files.length, files: data.files },
         "figma",
@@ -14964,7 +15460,7 @@ function registerFigmaCommands(program2) {
     const start = Date.now();
     const { success: success2, fail: fail2 } = await import("./output-HDUIIXUI.js");
     try {
-      const data = await getHttp5(program2).figma("/v1/me");
+      const data = await getHttp6(program2).figma("/v1/me");
       success2(data, "figma", "me", start);
     } catch (err) {
       fail2(err, "figma", "me", start);
@@ -14975,7 +15471,7 @@ function registerFigmaCommands(program2) {
 // src/services/alation/commands.ts
 import fs12 from "fs";
 var MAX_PAGE = 1e3;
-function parseIntOption(value, flag) {
+function parseIntOption2(value, flag) {
   if (value === void 0) return void 0;
   const trimmed = value.trim();
   if (!/^\d+$/.test(trimmed)) {
@@ -14991,8 +15487,8 @@ function parsePositiveId(value, what) {
   return Number(trimmed);
 }
 function pageParams(opts) {
-  const limit = parseIntOption(opts.limit, "--limit") ?? 100;
-  const skip = parseIntOption(opts.skip, "--skip") ?? 0;
+  const limit = parseIntOption2(opts.limit, "--limit") ?? 100;
+  const skip = parseIntOption2(opts.skip, "--skip") ?? 0;
   if (limit < 1 || limit > MAX_PAGE) {
     throw new PncliError(`--limit must be between 1 and ${MAX_PAGE} (Alation's per-request cap).`, 1);
   }
@@ -15079,17 +15575,17 @@ var ALATION_DOCUMENT_INPUT_FILE_EXAMPLE = {
   template: 7,
   fields: { "10001": "Team Data Platform" }
 };
-function getHttp6(program2) {
+function getHttp7(program2) {
   const opts = program2.optsWithGlobals();
   return createHttpClient(
     loadConfig({ configPath: opts.config }),
     Boolean(opts.dryRun)
   );
 }
-async function getOne(http, path14, id, what) {
-  const rows = await http.alation(path14, { params: { id, limit: 1 } });
-  const row = Array.isArray(rows) ? rows.find((r) => r.id === id) ?? rows[0] : void 0;
-  if (!row) throw new PncliError(`${what} ${id} not found`, 404);
+async function getOne(http, path14, id2, what) {
+  const rows = await http.alation(path14, { params: { id: id2, limit: 1 } });
+  const row = Array.isArray(rows) ? rows.find((r) => r.id === id2) ?? rows[0] : void 0;
+  if (!row) throw new PncliError(`${what} ${id2} not found`, 404);
   return row;
 }
 function buildDocumentPayload(opts) {
@@ -15155,17 +15651,17 @@ function registerAlationCommands(program2) {
       const params = {};
       if (opts.includeUndeployed) params.include_undeployed = true;
       if (opts.includeHidden) params.include_hidden = true;
-      const data = await getHttp6(program2).alation("integration/v1/datasource/", { params });
+      const data = await getHttp7(program2).alation("integration/v1/datasource/", { params });
       success({ count: data.length, datasources: data }, "alation", "datasource-list", start);
     } catch (err) {
       fail(err, "alation", "datasource-list", start);
     }
   });
-  datasource.command("get").description("Get a data source by ID").argument("<id>", "Data source ID").action(async (id) => {
+  datasource.command("get").description("Get a data source by ID").argument("<id>", "Data source ID").action(async (id2) => {
     const start = Date.now();
     try {
-      const dsId = parsePositiveId(id, "data source ID");
-      const data = await getHttp6(program2).alation(`integration/v1/datasource/${dsId}/`);
+      const dsId = parsePositiveId(id2, "data source ID");
+      const data = await getHttp7(program2).alation(`integration/v1/datasource/${dsId}/`);
       success(data, "alation", "datasource-get", start);
     } catch (err) {
       fail(err, "alation", "datasource-get", start);
@@ -15178,16 +15674,16 @@ function registerAlationCommands(program2) {
       const params = { ...pageParams(opts) };
       if (opts.ds) params.ds_id = parsePositiveId(opts.ds, "--ds");
       if (opts.name) params.name = opts.name;
-      const data = await getHttp6(program2).alation("integration/v2/schema/", { params });
+      const data = await getHttp7(program2).alation("integration/v2/schema/", { params });
       success({ count: data.length, limit: params.limit, skip: params.skip, schemas: data }, "alation", "schema-list", start);
     } catch (err) {
       fail(err, "alation", "schema-list", start);
     }
   });
-  schema.command("get").description("Get a schema by ID").argument("<id>", "Schema ID").action(async (id) => {
+  schema.command("get").description("Get a schema by ID").argument("<id>", "Schema ID").action(async (id2) => {
     const start = Date.now();
     try {
-      const data = await getOne(getHttp6(program2), "integration/v2/schema/", parsePositiveId(id, "schema ID"), "Schema");
+      const data = await getOne(getHttp7(program2), "integration/v2/schema/", parsePositiveId(id2, "schema ID"), "Schema");
       success(data, "alation", "schema-get", start);
     } catch (err) {
       fail(err, "alation", "schema-get", start);
@@ -15203,17 +15699,17 @@ function registerAlationCommands(program2) {
       if (opts.schemaName) params.schema_name = opts.schemaName;
       if (opts.name) params.name = opts.name;
       if (opts.search) params.name__icontains = opts.search;
-      const data = await getHttp6(program2).alation("integration/v2/table/", { params });
+      const data = await getHttp7(program2).alation("integration/v2/table/", { params });
       success({ count: data.length, limit: params.limit, skip: params.skip, tables: data }, "alation", "table-list", start);
     } catch (err) {
       fail(err, "alation", "table-list", start);
     }
   });
-  table.command("get").description("Get a table by ID, optionally with its columns").argument("<id>", "Table ID").option("--columns", "Also fetch the table's columns (up to 1000)").action(async (id, opts) => {
+  table.command("get").description("Get a table by ID, optionally with its columns").argument("<id>", "Table ID").option("--columns", "Also fetch the table's columns (up to 1000)").action(async (id2, opts) => {
     const start = Date.now();
     try {
-      const http = getHttp6(program2);
-      const tableId = parsePositiveId(id, "table ID");
+      const http = getHttp7(program2);
+      const tableId = parsePositiveId(id2, "table ID");
       const data = await getOne(http, "integration/v2/table/", tableId, "Table");
       if (opts.columns) {
         const columns = await http.alation("integration/v2/column/", {
@@ -15241,16 +15737,16 @@ function registerAlationCommands(program2) {
       if (opts.ds) params.ds_id = parsePositiveId(opts.ds, "--ds");
       if (opts.name) params.name = opts.name;
       if (opts.search) params.name__icontains = opts.search;
-      const data = await getHttp6(program2).alation("integration/v2/column/", { params });
+      const data = await getHttp7(program2).alation("integration/v2/column/", { params });
       success({ count: data.length, limit: params.limit, skip: params.skip, columns: data }, "alation", "column-list", start);
     } catch (err) {
       fail(err, "alation", "column-list", start);
     }
   });
-  column.command("get").description("Get a column by ID").argument("<id>", "Column ID").action(async (id) => {
+  column.command("get").description("Get a column by ID").argument("<id>", "Column ID").action(async (id2) => {
     const start = Date.now();
     try {
-      const data = await getOne(getHttp6(program2), "integration/v2/column/", parsePositiveId(id, "column ID"), "Column");
+      const data = await getOne(getHttp7(program2), "integration/v2/column/", parsePositiveId(id2, "column ID"), "Column");
       success(data, "alation", "column-get", start);
     } catch (err) {
       fail(err, "alation", "column-get", start);
@@ -15259,13 +15755,13 @@ function registerAlationCommands(program2) {
   alation.command("search").description("Full-text search across the catalog").argument("<query>", "Search text").option("--otype <types>", `Comma-separated object types to restrict to (e.g. table,column). Valid: ${SEARCH_OTYPES.join(", ")}`).option("--limit <n>", "Maximum results (default 20, max 10000)", "20").option("--offset <n>", "Index of the first result", "0").action(async (query, opts) => {
     const start = Date.now();
     try {
-      const limit = parseIntOption(opts.limit, "--limit") ?? 20;
-      const offset = parseIntOption(opts.offset, "--offset") ?? 0;
+      const limit = parseIntOption2(opts.limit, "--limit") ?? 20;
+      const offset = parseIntOption2(opts.offset, "--offset") ?? 0;
       if (limit > 1e4) throw new PncliError("--limit must be at most 10000", 1);
       const params = { q: query, limit, offset };
       const otypes = parseOtypes(opts.otype);
       if (otypes) params.filters = JSON.stringify({ otypes });
-      const data = await getHttp6(program2).alation("integration/v1/search/", { params });
+      const data = await getHttp7(program2).alation("integration/v1/search/", { params });
       success(
         { query, total: data.total, limit: data.limit, offset: data.offset, fullSearchUrl: data.full_search_url, results: data.results },
         "alation",
@@ -15284,16 +15780,16 @@ function registerAlationCommands(program2) {
       if (opts.hub) params.document_hub_id = parsePositiveId(opts.hub, "--hub");
       if (opts.parent) params.parent_folder_id = parsePositiveId(opts.parent, "--parent");
       if (opts.search) params.search = opts.search;
-      const data = await getHttp6(program2).alation("integration/v2/folder/", { params });
+      const data = await getHttp7(program2).alation("integration/v2/folder/", { params });
       success({ count: data.length, limit: params.limit, skip: params.skip, folders: data }, "alation", "folder-list", start);
     } catch (err) {
       fail(err, "alation", "folder-list", start);
     }
   });
-  folder.command("get").description("Get a Document Hub folder by ID").argument("<id>", "Folder ID").action(async (id) => {
+  folder.command("get").description("Get a Document Hub folder by ID").argument("<id>", "Folder ID").action(async (id2) => {
     const start = Date.now();
     try {
-      const data = await getOne(getHttp6(program2), "integration/v2/folder/", parsePositiveId(id, "folder ID"), "Folder");
+      const data = await getOne(getHttp7(program2), "integration/v2/folder/", parsePositiveId(id2, "folder ID"), "Folder");
       success(data, "alation", "folder-get", start);
     } catch (err) {
       fail(err, "alation", "folder-get", start);
@@ -15309,16 +15805,16 @@ function registerAlationCommands(program2) {
       if (opts.parentDocument) params.parent_document_id = parsePositiveId(opts.parentDocument, "--parent-document");
       if (opts.search) params.search = opts.search;
       if (opts.deleted) params.deleted = true;
-      const data = await getHttp6(program2).alation("integration/v2/document/", { params });
+      const data = await getHttp7(program2).alation("integration/v2/document/", { params });
       success({ count: data.length, limit: params.limit, skip: params.skip, documents: data }, "alation", "document-list", start);
     } catch (err) {
       fail(err, "alation", "document-list", start);
     }
   });
-  document.command("get").description("Get a document by ID, including its custom field values").argument("<id>", "Document ID").action(async (id) => {
+  document.command("get").description("Get a document by ID, including its custom field values").argument("<id>", "Document ID").action(async (id2) => {
     const start = Date.now();
     try {
-      const data = await getOne(getHttp6(program2), "integration/v2/document/", parsePositiveId(id, "document ID"), "Document");
+      const data = await getOne(getHttp7(program2), "integration/v2/document/", parsePositiveId(id2, "document ID"), "Document");
       success(data, "alation", "document-get", start);
     } catch (err) {
       fail(err, "alation", "document-get", start);
@@ -15339,16 +15835,16 @@ function registerAlationCommands(program2) {
       for (const [key, flag] of [["title", "--title"], ["document_hub_id", "--hub"], ["parent_folder_id", "--folder"]]) {
         if (payload[key] === void 0) throw new PncliError(`${flag} is required to create a document (or set it in --input-file)`, 1);
       }
-      const data = await getHttp6(program2).alation("integration/v2/document/", { method: "POST", body: [payload] });
+      const data = await getHttp7(program2).alation("integration/v2/document/", { method: "POST", body: [payload] });
       success({ jobId: data.job_id, document: payload, ...overrides.length ? { overrides } : {} }, "alation", "document-create", start);
     } catch (err) {
       fail(err, "alation", "document-create", start);
     }
   });
-  document.command("update").description("Update a document (async \u2014 returns a job ID; custom field values replace existing values per field)").argument("<id>", "Document ID").option("--title <title>", "New title").option("--description <text>", "New summary").option("--folder <id>", "Move to this parent folder").option("--template <id>", "Template ID (required when custom fields are set)").option("--input-file <path>", 'JSON file with title/description/folder/template/fields (see `alation document schema`); "-" reads stdin').action(async (id, opts) => {
+  document.command("update").description("Update a document (async \u2014 returns a job ID; custom field values replace existing values per field)").argument("<id>", "Document ID").option("--title <title>", "New title").option("--description <text>", "New summary").option("--folder <id>", "Move to this parent folder").option("--template <id>", "Template ID (required when custom fields are set)").option("--input-file <path>", 'JSON file with title/description/folder/template/fields (see `alation document schema`); "-" reads stdin').action(async (id2, opts) => {
     const start = Date.now();
     try {
-      const documentId = parsePositiveId(id, "document ID");
+      const documentId = parsePositiveId(id2, "document ID");
       const { payload, overrides } = buildDocumentPayload(opts);
       if (payload.document_hub_id !== void 0) {
         throw new PncliError('A document cannot change hubs; remove "hub" from --input-file.', 1);
@@ -15357,18 +15853,18 @@ function registerAlationCommands(program2) {
         throw new PncliError("Nothing to update. Pass --title, --description, --folder, or --input-file.", 1);
       }
       const body = [{ id: documentId, ...payload }];
-      const data = await getHttp6(program2).alation("integration/v2/document/", { method: "PUT", body });
+      const data = await getHttp7(program2).alation("integration/v2/document/", { method: "PUT", body });
       success({ jobId: data.job_id, document: body[0], ...overrides.length ? { overrides } : {} }, "alation", "document-update", start);
     } catch (err) {
       fail(err, "alation", "document-update", start);
     }
   });
   const job = alation.command("job").description("Background job operations");
-  job.command("get").description("Get the status of a bulk job (returned by document create/update)").argument("<id>", "Job ID").action(async (id) => {
+  job.command("get").description("Get the status of a bulk job (returned by document create/update)").argument("<id>", "Job ID").action(async (id2) => {
     const start = Date.now();
     try {
-      const jobId = parsePositiveId(id, "job ID");
-      const data = await getHttp6(program2).alation("api/v1/bulk_metadata/job/", { params: { id: jobId } });
+      const jobId = parsePositiveId(id2, "job ID");
+      const data = await getHttp7(program2).alation("api/v1/bulk_metadata/job/", { params: { id: jobId } });
       success({ jobId, ...data }, "alation", "job-get", start);
     } catch (err) {
       fail(err, "alation", "job-get", start);
@@ -15377,9 +15873,7 @@ function registerAlationCommands(program2) {
 }
 
 // src/cli.ts
-if (!process.env.PNCLI_VERIFY_TLS) {
-  process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
-}
+configureTls();
 await configureProxy();
 var TAGLINE = "Connectivity without MCP.";
 var program = new Command3();
@@ -15422,6 +15916,7 @@ registerLogscaleCommands(program);
 registerSplitioCommands(program);
 registerFigmaCommands(program);
 registerAlationCommands(program);
+registerSauceLabsCommands(program);
 program.addHelpText("after", `
 Services:
   git          Local git operations (status, diff, log, branch)
@@ -15444,6 +15939,7 @@ Services:
   splitio      Split.IO (feature flags, Change Requests)
   figma        Figma (files, comments, version history)
   alation      Alation (data sources, schemas, tables, columns, search, Document Hubs)
+  saucelabs    Sauce Labs (jobs, builds, real devices and device sessions, tunnels, platforms)
   config       Manage pncli configuration (and OS keychain storage for credentials)
   doctor       Diagnose pncli setup (config, credentials, keychain, git auth, agent skills, marketplaces)
   skills       Install and manage agent skills (Codex, GitHub Copilot, Claude Code)