@seleniumbox/sbox-mcp 1.0.0

package/dist/services/analytics.service.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Analytics service: sessions per browser, by build, failed count, most active project/user.
+ * Time range can be in hours, minutes, or days.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAnalyticsService = createAnalyticsService;
+function createAnalyticsService(statsAdapter) {
+    return {
+        async totalTests(token, days) {
+            const res = await statsAdapter.getTotalTests(token, days);
+            if (res.status !== 200) {
+                return { success: false, status: res.status, message: res.error ?? "Failed to get total tests" };
+            }
+            return { success: true, total: res.total };
+        },
+        async sessionsPerBrowser(token, timeRange) {
+            const res = await statsAdapter.getSessionsPerBrowser(token, timeRange);
+            if (res.status !== 200) {
+                return { success: false, status: res.status, message: res.error ?? "Failed to get sessions per browser" };
+            }
+            const data = res.items.map((i) => ({
+                browser: i.browser ?? "",
+                version: i.version ?? "",
+                count: i.count ?? 0,
+            }));
+            return { success: true, data };
+        },
+        async sessionsByBuild(token, timeRange) {
+            const res = await statsAdapter.getSessionsByBuild(token, timeRange);
+            if (res.status !== 200) {
+                return { success: false, status: res.status, message: res.error ?? "Failed to get sessions by build" };
+            }
+            const data = res.items.map((i) => ({
+                buildName: i.buildName ?? "Others",
+                sessionCount: i.session_count ?? 0,
+            }));
+            return { success: true, data };
+        },
+        async failedCount(token, timeRange) {
+            const res = await statsAdapter.getCountByStatus(token, timeRange);
+            if (res.status !== 200) {
+                return { success: false, status: res.status, message: res.error ?? "Failed to get failed count" };
+            }
+            let count = 0;
+            for (const item of res.items) {
+                const r = (item.result ?? "").toLowerCase();
+                if (r === "failed" || r === "timeout")
+                    count += item.count ?? 0;
+            }
+            return { success: true, count };
+        },
+        async mostActiveProject(token, timeRange) {
+            const res = await statsAdapter.getCountPerProject(token, timeRange);
+            if (res.status !== 200) {
+                return { success: false, status: res.status, message: res.error ?? "Failed to get most active project" };
+            }
+            const top = res.items.sort((a, b) => (b.count ?? 0) - (a.count ?? 0))[0];
+            if (!top) {
+                return { success: true, projectName: "N/A", count: 0 };
+            }
+            return { success: true, projectName: top.project ?? "N/A", count: top.count ?? 0 };
+        },
+        async mostActiveUser(token, timeRange) {
+            const res = await statsAdapter.getCountPerUser(token, timeRange);
+            if (res.status !== 200) {
+                return { success: false, status: res.status, message: res.error ?? "Failed to get most active user" };
+            }
+            const top = res.items.sort((a, b) => (b.count ?? 0) - (a.count ?? 0))[0];
+            if (!top) {
+                return { success: true, userName: "N/A", count: 0 };
+            }
+            return { success: true, userName: top.user ?? "N/A", count: top.count ?? 0 };
+        },
+        async testsPerTestName(token, timeRange) {
+            const res = await statsAdapter.getCountPerTestName(token, timeRange);
+            if (res.status !== 200) {
+                return { success: false, status: res.status, message: res.error ?? "Failed to get tests per test name" };
+            }
+            const data = res.items.map((i) => ({
+                testName: i.testName ?? "",
+                count: i.count ?? 0,
+            }));
+            return { success: true, data };
+        },
+        async manualTestsPerTestName(token, timeRange) {
+            const res = await statsAdapter.getManualCountPerTestName(token, timeRange);
+            if (res.status !== 200) {
+                return { success: false, status: res.status, message: res.error ?? "Failed to get manual tests per test name" };
+            }
+            const data = res.items.map((i) => ({
+                testName: i.testName ?? "",
+                count: i.count ?? 0,
+            }));
+            return { success: true, data };
+        },
+    };
+}

package/dist/services/auth.service.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Authentication service. Delegates to auth adapter; returns DTOs.
+ * Exposes customer-friendly auth type (Local, LDAP, OIDC) only; internal realm id is not exposed.
+ */
+import type { AuthAdapter } from "../adapters/auth.adapter";
+import type { LoginBody, LoginResponseDto } from "../dto/auth.dto";
+export interface AuthService {
+    isMcpAddonEnabled(): Promise<boolean>;
+    login(body: LoginBody): Promise<{
+        success: true;
+        data: LoginResponseDto;
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+    validateToken(token: string): Promise<{
+        success: true;
+        data: LoginResponseDto;
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+    pollForToken(pollId: string): Promise<string | null>;
+}
+export declare function createAuthService(adapter: AuthAdapter): AuthService;

package/dist/services/auth.service.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * Authentication service. Delegates to auth adapter; returns DTOs.
+ * Exposes customer-friendly auth type (Local, LDAP, OIDC) only; internal realm id is not exposed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthService = createAuthService;
+/** Map internal realm id to customer-facing auth type. */
+function realmIdToAuthType(realmId) {
+    if (realmId == null || realmId === "")
+        return "Local";
+    const r = String(realmId).toLowerCase();
+    if (r === "0" || r === "local")
+        return "Local";
+    if (r.includes("ldap"))
+        return "LDAP";
+    if (r.includes("oidc") || r.includes("openid"))
+        return "OIDC";
+    return "Local";
+}
+function createAuthService(adapter) {
+    return {
+        async isMcpAddonEnabled() {
+            return adapter.isMcpAddonEnabled();
+        },
+        async login(body) {
+            const payload = { username: body.username, password: body.password };
+            const { status, data } = await adapter.login(payload);
+            if (status !== 200 || "success" in data && data.success === false) {
+                const msg = data.message ?? "Login failed";
+                return { success: false, status, message: msg };
+            }
+            const session = data;
+            const dto = {
+                token: session.token,
+                principal: {
+                    userId: session.principal?.userId ?? body.username,
+                    fullname: session.principal?.fullname,
+                    authType: realmIdToAuthType(session.principal?.realm?.id),
+                },
+            };
+            return { success: true, data: dto };
+        },
+        async validateToken(token) {
+            const { status, data } = await adapter.validateSession(token);
+            if (status !== 200 || "success" in data && data.success === false) {
+                const msg = data.message ?? "Invalid or expired token";
+                return { success: false, status, message: msg };
+            }
+            const session = data;
+            const dto = {
+                token: session.token,
+                principal: {
+                    userId: session.principal?.userId ?? "",
+                    fullname: session.principal?.fullname,
+                    authType: realmIdToAuthType(session.principal?.realm?.id),
+                },
+            };
+            return { success: true, data: dto };
+        },
+        async pollForToken(pollId) {
+            const { status, data } = await adapter.pollToken(pollId);
+            if (status === 200 && data && typeof data.token === "string" && data.token)
+                return data.token;
+            return null;
+        },
+    };
+}

package/dist/services/browser.service.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Browser service: list supported browsers, Playwright versions.
+ * Uses browser adapter; returns business-friendly DTOs.
+ */
+import type { BrowserAdapter } from "../adapters/browser.adapter";
+import type { BrowserDto, PlaywrightVersionDto } from "../dto/browser.dto";
+export interface BrowserService {
+    listSupportedBrowsers(token: string): Promise<{
+        success: true;
+        data: BrowserDto[];
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+    listPlaywrightVersions(token: string): Promise<{
+        success: true;
+        data: PlaywrightVersionDto[];
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+}
+export declare function createBrowserService(adapter: BrowserAdapter): BrowserService;

package/dist/services/browser.service.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Browser service: list supported browsers, Playwright versions.
+ * Uses browser adapter; returns business-friendly DTOs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBrowserService = createBrowserService;
+const browser_adapter_1 = require("../adapters/browser.adapter");
+function toPlaywrightDto(raw) {
+    return {
+        version: raw.version ?? "",
+        chromium: raw.chromium ?? "",
+        webkit: raw.webkit ?? "",
+        firefox: raw.firefox ?? "",
+    };
+}
+function createBrowserService(adapter) {
+    return {
+        async listSupportedBrowsers(token) {
+            const results = [];
+            for (const name of browser_adapter_1.BROWSER_NAMES) {
+                const res = await adapter.getBrowserVersions(name, token);
+                if (res.status === 200 && res.versions.length > 0) {
+                    results.push({
+                        browserName: res.name,
+                        version: res.versions[0] ?? "",
+                        platform: "desktop",
+                        capabilities: { versions: res.versions },
+                    });
+                }
+            }
+            return { success: true, data: results };
+        },
+        async listPlaywrightVersions(token) {
+            const res = await adapter.getPlaywrightVersions(token);
+            if (res.status !== 200) {
+                return { success: false, status: res.status, message: res.error ?? "Playwright is not enabled" };
+            }
+            const data = res.versions.map(toPlaywrightDto);
+            return { success: true, data };
+        },
+    };
+}

package/dist/services/device.service.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Device service: list supported devices (iOS, Android, mobile web).
+ * - iOS: GET /e34/api/mobile/ios/devices (deviceName, iosSDK list) when iOS is enabled / executors attached.
+ * - Android: GET /e34/api/mobile/android/devices (avdName, deviceName, completeDeviceName, supportedPlatformVersions).
+ */
+import type { DeviceAdapter } from "../adapters/device.adapter";
+import type { DeviceDto } from "../dto/device.dto";
+export interface DeviceService {
+    listSupportedDevices(token: string): Promise<{
+        success: true;
+        data: DeviceDto[];
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+}
+export declare function createDeviceService(adapter: DeviceAdapter): DeviceService;

package/dist/services/device.service.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Device service: list supported devices (iOS, Android, mobile web).
+ * - iOS: GET /e34/api/mobile/ios/devices (deviceName, iosSDK list) when iOS is enabled / executors attached.
+ * - Android: GET /e34/api/mobile/android/devices (avdName, deviceName, completeDeviceName, supportedPlatformVersions).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeviceService = createDeviceService;
+function iosToDto(raw) {
+    const sdks = raw.iosSDK ?? raw.iossdks ?? raw.IOSSDK ?? [];
+    const versions = sdks
+        .map((s) => (typeof s === "object" && s && "name" in s ? s.name : String(s)))
+        .filter((v) => typeof v === "string" && v.length > 0);
+    return {
+        deviceName: raw.deviceName ?? "Unknown",
+        os: "iOS",
+        version: versions[0] ?? "",
+        supportedPlatformVersions: versions.length > 0 ? versions : undefined,
+    };
+}
+function androidToDto(raw) {
+    const versions = raw.supportedPlatformVersions ?? [];
+    return {
+        deviceName: raw.deviceName ?? raw.completeDeviceName ?? "Unknown",
+        completeDeviceName: raw.completeDeviceName,
+        avdName: raw.avdName,
+        os: "Android",
+        version: versions[0] ?? "",
+        supportedPlatformVersions: versions.length > 0 ? versions : undefined,
+    };
+}
+function toDto(raw, platform) {
+    return {
+        deviceName: raw.deviceName ?? raw.name ?? "Unknown",
+        os: raw.os ?? platform,
+        version: raw.version ?? "",
+        availability: raw.available === true ? "available" : "unavailable",
+    };
+}
+function createDeviceService(adapter) {
+    return {
+        async listSupportedDevices(token) {
+            const [ios, android, mobileWeb] = await Promise.all([
+                adapter.getIosDevices(token),
+                adapter.getAndroidDevices(token),
+                adapter.getMobileWebDevices(token),
+            ]);
+            const list = [];
+            if (ios.status === 200)
+                ios.devices.forEach((d) => list.push(iosToDto(d)));
+            if (android.status === 200)
+                android.devices.forEach((d) => list.push(androidToDto(d)));
+            if (mobileWeb.status === 200)
+                mobileWeb.devices.forEach((d) => list.push(toDto(d, "MobileWeb")));
+            return { success: true, data: list };
+        },
+    };
+}

package/dist/services/diagnostics.service.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Diagnostics service: system metrics for the Diagnostics Dashboard.
+ * CPU usage, queued tests, active tests, queue waiting time, tests across executors, tests in starting state, executor count.
+ */
+import type { DiagnosticsAdapter } from "../adapters/diagnostics.adapter";
+export interface DiagnosticsService {
+    getExecutorsCount(token: string): Promise<{
+        success: true;
+        count: number;
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+    getCpuUsagePerNode(token: string, days: number): Promise<{
+        success: true;
+        data: Array<{
+            node: string;
+            avgCpu: number;
+            timestamp: string;
+        }>;
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+    getTestsQueuedHourly(token: string, days: number): Promise<{
+        success: true;
+        data: Array<{
+            timestamp: string;
+            avgTotal: number;
+            maxTotal: number;
+        }>;
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+    getNodesActiveTests(token: string, days: number): Promise<{
+        success: true;
+        data: Array<{
+            timestamp: string;
+            averageTotal: number;
+        }>;
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+    getQueueWaitingTime(token: string, days: number): Promise<{
+        success: true;
+        data: Array<{
+            timestamp: string;
+            avgDuration: number;
+            maxDuration: number;
+        }>;
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+    getTestsActiveGraph(token: string, days: number): Promise<{
+        success: true;
+        data: Array<{
+            timestamp: string;
+            avgTotal: number;
+            node: string;
+        }>;
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+    getTestsStartingStats(token: string, days: number): Promise<{
+        success: true;
+        data: Array<{
+            timestamp: string;
+            node: string;
+            avgTotal: number;
+        }>;
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+}
+export declare function createDiagnosticsService(adapter: DiagnosticsAdapter): DiagnosticsService;

package/dist/services/diagnostics.service.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Diagnostics service: system metrics for the Diagnostics Dashboard.
+ * CPU usage, queued tests, active tests, queue waiting time, tests across executors, tests in starting state, executor count.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDiagnosticsService = createDiagnosticsService;
+function createDiagnosticsService(adapter) {
+    return {
+        async getExecutorsCount(token) {
+            const res = await adapter.getExecutorsCount(token);
+            if (res.status !== 200) {
+                return { success: false, status: res.status, message: res.error ?? "Failed to get executors count" };
+            }
+            return { success: true, count: res.count };
+        },
+        async getCpuUsagePerNode(token, days) {
+            const res = await adapter.getCpuUsagePerNode(token, days);
+            if (res.status !== 200) {
+                return { success: false, status: res.status, message: res.error ?? "Failed to get CPU usage" };
+            }
+            const data = res.items.map((i) => ({
+                node: i.node ?? "",
+                avgCpu: i.avg_cpu ?? 0,
+                timestamp: i.timestamp ?? "",
+            }));
+            return { success: true, data };
+        },
+        async getTestsQueuedHourly(token, days) {
+            const res = await adapter.getTestsQueuedHourly(token, days);
+            if (res.status !== 200) {
+                return { success: false, status: res.status, message: res.error ?? "Failed to get tests queued hourly" };
+            }
+            const data = res.items.map((i) => ({
+                timestamp: i.timestamp ?? "",
+                avgTotal: i.avg_total ?? 0,
+                maxTotal: i.max_total ?? 0,
+            }));
+            return { success: true, data };
+        },
+        async getNodesActiveTests(token, days) {
+            const res = await adapter.getNodesActiveTests(token, days);
+            if (res.status !== 200) {
+                return { success: false, status: res.status, message: res.error ?? "Failed to get active tests" };
+            }
+            const data = res.items.map((i) => ({
+                timestamp: i.timestamp ?? "",
+                averageTotal: i.average_total ?? 0,
+            }));
+            return { success: true, data };
+        },
+        async getQueueWaitingTime(token, days) {
+            const res = await adapter.getQueueWaitingTime(token, days);
+            if (res.status !== 200) {
+                return { success: false, status: res.status, message: res.error ?? "Failed to get queue waiting time" };
+            }
+            const data = res.items.map((i) => {
+                const b = i.browsers?.[0];
+                return {
+                    timestamp: i.timestamp ?? "",
+                    avgDuration: b?.avg_duration ?? 0,
+                    maxDuration: b?.max_duration ?? 0,
+                };
+            });
+            return { success: true, data };
+        },
+        async getTestsActiveGraph(token, days) {
+            const res = await adapter.getTestsActiveGraph(token, days);
+            if (res.status !== 200) {
+                return { success: false, status: res.status, message: res.error ?? "Failed to get tests active graph" };
+            }
+            const data = res.items.map((i) => ({
+                timestamp: i.timestamp ?? "",
+                avgTotal: i.avg_total ?? 0,
+                node: i.node ?? "",
+            }));
+            return { success: true, data };
+        },
+        async getTestsStartingStats(token, days) {
+            const res = await adapter.getTestsStartingStats(token, days);
+            if (res.status !== 200) {
+                return { success: false, status: res.status, message: res.error ?? "Failed to get tests starting stats" };
+            }
+            const data = res.items.map((i) => ({
+                timestamp: i.timestamp ?? "",
+                node: i.node ?? "",
+                avgTotal: i.avg_total ?? 0,
+            }));
+            return { success: true, data };
+        },
+    };
+}

package/dist/services/enrichment.service.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Enrichment service: maps raw SBOX API data to business-friendly DTOs.
+ * Never exposes internal IDs; always uses names (projectName, userName, browserName, deviceName).
+ */
+import type { ESSessionDataRaw } from "../adapters/session.adapter";
+import type { SessionDetailDto } from "../dto/session.dto";
+/** Video files are served at /videos/{ekey}.mp4 (not under /e34/api). */
+export declare function buildVideoUrl(sessionId: string): string;
+export declare function enrichSessionDetail(raw: ESSessionDataRaw, videoUrl: string | null): SessionDetailDto;

package/dist/services/enrichment.service.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Enrichment service: maps raw SBOX API data to business-friendly DTOs.
+ * Never exposes internal IDs; always uses names (projectName, userName, browserName, deviceName).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildVideoUrl = buildVideoUrl;
+exports.enrichSessionDetail = enrichSessionDetail;
+const config_1 = require("../config");
+const EXTRAS_PREFIX = "e34:";
+function getExtra(raw, key) {
+    const extras = raw.extras ?? {};
+    const v = extras[EXTRAS_PREFIX + key];
+    if (v === undefined || v === null)
+        return null;
+    return String(v);
+}
+function getExtraNumber(raw, key) {
+    const extras = raw.extras ?? {};
+    const v = extras[EXTRAS_PREFIX + key];
+    if (v === undefined || v === null)
+        return null;
+    const n = typeof v === "number" ? v : Number(v);
+    return Number.isFinite(n) ? n : null;
+}
+/** Video files are served at /videos/{ekey}.mp4 (not under /e34/api). */
+function buildVideoUrl(sessionId) {
+    const base = config_1.config.sboxApiBaseUrl.replace(/\/$/, "");
+    return `${base}/videos/${encodeURIComponent(sessionId)}.mp4`;
+}
+/** Internal keys we never expose (IDs and raw longs). */
+const CAPABILITIES_OMIT = new Set([
+    "e34:project_Id",
+    "e34:u_realmId",
+    "e34:arrival",
+]);
+/**
+ * Build a capabilities object from raw session: extras (e34:*) plus top-level session fields.
+ * Omits internal IDs (project_Id, u_realmId) and raw arrival long; uses project name and human-readable arrival time.
+ */
+function buildCapabilities(raw) {
+    const extras = raw.extras ?? {};
+    const caps = {};
+    for (const [key, value] of Object.entries(extras)) {
+        if (CAPABILITIES_OMIT.has(key))
+            continue;
+        if (key === "e34:projectId") {
+            caps.projectName = value;
+            continue;
+        }
+        caps[key] = value;
+    }
+    if (raw.browser != null)
+        caps.browser = raw.browser;
+    if (raw.version != null)
+        caps.version = raw.version;
+    if (raw.browserVersion != null)
+        caps.browserVersion = raw.browserVersion;
+    if (raw.framework != null)
+        caps.framework = raw.framework;
+    if (raw.platformName != null)
+        caps.platformName = raw.platformName;
+    if (raw.deviceName != null)
+        caps.deviceName = raw.deviceName;
+    if (raw.platformVersion != null)
+        caps.platformVersion = raw.platformVersion;
+    if (raw.originIp != null)
+        caps.originIp = raw.originIp;
+    if (raw.node != null)
+        caps.node = raw.node;
+    if (raw.duration != null)
+        caps.duration = raw.duration;
+    const arrivalMs = getExtraNumber(raw, "arrival");
+    if (arrivalMs != null)
+        caps.arrivalTime = new Date(arrivalMs).toISOString();
+    return caps;
+}
+function enrichSessionDetail(raw, videoUrl) {
+    const sessionId = raw.ekey ?? "";
+    const projectName = getExtra(raw, "projectId") ?? "";
+    const userName = getExtra(raw, "userId") ?? "";
+    const browserName = raw.browser ?? raw.browserVersion ?? "";
+    const browserVersion = raw.version ?? raw.browserVersion ?? "";
+    const deviceName = raw.deviceName ?? raw.platformName ?? "";
+    const status = raw.result ?? "unknown";
+    const framework = raw.framework ?? "selenium";
+    const arrivalMs = getExtraNumber(raw, "arrival");
+    const durationMs = typeof raw.duration === "number" && Number.isFinite(raw.duration) ? raw.duration : null;
+    const startTime = arrivalMs != null
+        ? new Date(arrivalMs).toISOString()
+        : (raw["@timestamp"] ?? getExtra(raw, "startTime") ?? null)
+            ? String(raw["@timestamp"] ?? getExtra(raw, "startTime"))
+            : null;
+    const endTime = startTime && arrivalMs != null && durationMs != null
+        ? new Date(arrivalMs + durationMs).toISOString()
+        : (getExtra(raw, "endTime") ?? null);
+    return {
+        sessionId,
+        projectName,
+        browserName,
+        browserVersion,
+        deviceName,
+        userName,
+        status,
+        framework,
+        startTime,
+        endTime,
+        durationMs,
+        videoUrl,
+        capabilities: buildCapabilities(raw),
+    };
+}

package/dist/services/index.d.ts

@@ -0,0 +1,20 @@
+export declare const authService: import("./auth.service").AuthService;
+export declare const sessionService: import("./session.service").SessionService;
+export declare const browserService: import("./browser.service").BrowserService;
+export declare const deviceService: import("./device.service").DeviceService;
+export declare const userService: import("./user.service").UserService;
+export declare const sessionsPerProjectService: import("./sessions-per-project.service").SessionsPerProjectService;
+export declare const uploadService: import("./upload.service").UploadService;
+export declare const analyticsService: import("./analytics.service").AnalyticsService;
+export declare const diagnosticsService: import("./diagnostics.service").DiagnosticsService;
+export declare const projectService: import("./project.service").ProjectService;
+export type { AuthService } from "./auth.service";
+export type { SessionService } from "./session.service";
+export type { BrowserService } from "./browser.service";
+export type { DeviceService } from "./device.service";
+export type { UserService } from "./user.service";
+export type { SessionsPerProjectService } from "./sessions-per-project.service";
+export type { UploadService } from "./upload.service";
+export type { AnalyticsService } from "./analytics.service";
+export type { DiagnosticsService } from "./diagnostics.service";
+export type { ProjectService } from "./project.service";