Feat: Refactor session management to support desktop and mobile filtering with improved OS and browser version handling

Author: ruturaj-browserstack

src/tools/applive-utils/start-session.ts

@@ -221,7 +221,7 @@ function openBrowser(launchUrl: string): void {
         : process.platform === "win32"
           ? ["cmd", "/c", "start", launchUrl]
           : ["xdg-open", launchUrl];
-    
+
     // nosemgrep:javascript.lang.security.detect-child-process.detect-child-process
     const child = childProcess.spawn(command[0], command.slice(1), {
       stdio: "ignore",

src/tools/live-utils/desktop-filter.ts

@@ -0,0 +1,141 @@
+import { getLiveData } from "./device-cache";
+import { resolveVersion } from "./version-resolver";
+import { customFuzzySearch } from "../../lib/fuzzy";
+import { DesktopArgs, DesktopEntry } from "./types";
+
+export async function filterDesktop(args: DesktopArgs): Promise<DesktopEntry> {
+  const data = await getLiveData();
+  const allEntries = getAllDesktopEntries(data);
+
+  // Filter OS
+  const osList = filterByOS(allEntries, args.os);
+
+  // Filter browser
+  const browserList = filterByBrowser(osList, args.browser, args.os);
+
+  // Resolve OS version
+  const uniqueOSVersions = getUniqueOSVersions(browserList);
+  const chosenOS = resolveOSVersion(args.os, args.osVersion, uniqueOSVersions);
+
+  // Filter entries based on chosen OS version
+  const entriesForOS = filterByOSVersion(browserList, chosenOS);
+
+  // Resolve browser version
+  const browserVersions = entriesForOS.map((e) => e.browser_version);
+  const chosenBrowserVersion = resolveVersion(
+    args.browserVersion,
+    browserVersions,
+  );
+
+  // Find final entry
+  const finalEntry = entriesForOS.find(
+    (e) => e.browser_version === chosenBrowserVersion,
+  );
+  if (!finalEntry) {
+    throw new Error(`No entry for browser version "${args.browserVersion}".`);
+  }
+
+  // Add notes if versions were adjusted
+  addNotes(finalEntry, args, chosenOS, chosenBrowserVersion);
+
+  return finalEntry;
+}
+
+function getAllDesktopEntries(data: any): DesktopEntry[] {
+  return data.desktop.flatMap((plat: any) =>
+    plat.browsers.map((b: any) => ({
+      os: plat.os,
+      os_version: plat.os_version,
+      browser: b.browser,
+      browser_version: b.browser_version,
+    })),
+  );
+}
+
+function filterByOS(entries: DesktopEntry[], os: string): DesktopEntry[] {
+  const filtered = entries.filter((e) => e.os === os);
+  if (!filtered.length) throw new Error(`No OS entries for "${os}".`);
+  return filtered;
+}
+
+function filterByBrowser(
+  entries: DesktopEntry[],
+  browser: string,
+  os: string,
+): DesktopEntry[] {
+  const filtered = entries.filter((e) => e.browser === browser);
+  if (!filtered.length) throw new Error(`No browser "${browser}" on ${os}.`);
+  return filtered;
+}
+
+function getUniqueOSVersions(entries: DesktopEntry[]): string[] {
+  return Array.from(new Set(entries.map((e) => e.os_version)));
+}
+
+function resolveOSVersion(
+  os: string,
+  requestedVersion: string,
+  availableVersions: string[],
+): string {
+  if (os === "OS X") {
+    return resolveMacOSVersion(requestedVersion, availableVersions);
+  } else {
+    // For Windows, use semantic versioning
+    return resolveVersion(requestedVersion, availableVersions);
+  }
+}
+
+function resolveMacOSVersion(requested: string, available: string[]): string {
+  if (requested === "latest") {
+    return available[available.length - 1];
+  } else if (requested === "oldest") {
+    return available[0];
+  } else {
+    // Try fuzzy matching
+    const fuzzy = customFuzzySearch(
+      available.map((v) => ({ os_version: v })),
+      ["os_version"],
+      requested,
+      1,
+    );
+    const matched = fuzzy.length ? fuzzy[0].os_version : requested;
+
+    // Fallback if not valid
+    return available.includes(matched) ? matched : available[0];
+  }
+}
+
+function filterByOSVersion(
+  entries: DesktopEntry[],
+  osVersion: string,
+): DesktopEntry[] {
+  return entries.filter((e) => e.os_version === osVersion);
+}
+
+function addNotes(
+  entry: DesktopEntry,
+  args: DesktopArgs,
+  resolvedOS: string,
+  resolvedBrowser: string,
+): void {
+  if (
+    args.osVersion !== resolvedOS &&
+    args.osVersion !== "latest" &&
+    args.osVersion !== "oldest"
+  ) {
+    entry.notes = `Note: OS version ${args.osVersion} was not found. Using "${resolvedOS}" instead.`;
+  }
+
+  if (
+    args.browserVersion !== resolvedBrowser &&
+    args.browserVersion !== "latest" &&
+    args.browserVersion !== "oldest"
+  ) {
+    if (!entry.notes) {
+      entry.notes = `Note: `;
+    } else {
+      entry.notes += ` `;
+    }
+    entry.notes += `Browser version ${args.browserVersion} was not found. Using "${resolvedBrowser}" instead.`;
+  }
+}

src/tools/live-utils/mobile-filter.ts

@@ -0,0 +1,102 @@
+import { getLiveData } from "./device-cache";
+import { resolveVersion } from "./version-resolver";
+import { customFuzzySearch } from "../../lib/fuzzy";
+import { MobileArgs, MobileEntry } from "./types";
+
+// Extract all mobile entries from the data
+function getAllMobileEntries(data: any): MobileEntry[] {
+  return data.mobile.flatMap((grp: any) =>
+    grp.devices.map((d: any) => ({
+      os: grp.os,
+      os_version: d.os_version,
+      display_name: d.display_name,
+      notes: "",
+    })),
+  );
+}
+
+// Filter entries by OS
+function filterByOS(entries: MobileEntry[], os: string): MobileEntry[] {
+  const candidates = entries.filter((d) => d.os === os);
+  if (!candidates.length) throw new Error(`No mobile OS entries for "${os}".`);
+  return candidates;
+}
+
+// Find matching device with exact match validation
+function findMatchingDevice(
+  entries: MobileEntry[],
+  deviceName: string,
+  os: string,
+): MobileEntry[] {
+  const matches = customFuzzySearch(entries, ["display_name"], deviceName, 5);
+  if (!matches.length)
+    throw new Error(`No devices matching "${deviceName}" on ${os}.`);
+
+  const exact = matches.find(
+    (m) => m.display_name.toLowerCase() === deviceName.toLowerCase(),
+  );
+  if (!exact) {
+    const names = matches.map((m) => m.display_name).join(", ");
+    throw new Error(
+      `Alternative Device/Device's found : ${names}. Please Select one.`,
+    );
+  }
+
+  const result = entries.filter((d) => d.display_name === exact.display_name);
+  if (!result.length)
+    throw new Error(`No device "${exact.display_name}" on ${os}.`);
+
+  return result;
+}
+
+// Find the appropriate OS version
+function findOSVersion(
+  entries: MobileEntry[],
+  requestedVersion: string,
+): { entries: MobileEntry[]; chosenVersion: string } {
+  const versions = entries.map((d) => d.os_version);
+  const chosenVersion = resolveVersion(requestedVersion, versions);
+
+  const result = entries.filter((d) => d.os_version === chosenVersion);
+  if (!result.length)
+    throw new Error(`No entry for OS version "${requestedVersion}".`);
+
+  return { entries: result, chosenVersion };
+}
+
+// Create version note if needed
+function createVersionNote(
+  requestedVersion: string,
+  actualVersion: string,
+): string {
+  if (
+    actualVersion !== requestedVersion &&
+    requestedVersion !== "latest" &&
+    requestedVersion !== "oldest"
+  ) {
+    return `Note: Os version ${requestedVersion} was not found. Using ${actualVersion} instead.`;
+  }
+  return "";
+}
+
+export async function filterMobile(args: MobileArgs): Promise<MobileEntry> {
+  const data = await getLiveData();
+  const allEntries = getAllMobileEntries(data);
+
+  const osCandidates = filterByOS(allEntries, args.os);
+  const deviceCandidates = findMatchingDevice(
+    osCandidates,
+    args.device,
+    args.os,
+  );
+
+  const { entries: versionCandidates, chosenVersion } = findOSVersion(
+    deviceCandidates,
+    args.osVersion,
+  );
+
+  const final = versionCandidates[0];
+  final.notes = createVersionNote(args.osVersion, chosenVersion);
+
+  return final;
+}