@seleniumbox/sbox-mcp 0.2.0

package/dist/middleware/debug-log.middleware.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * When MCP_DEBUG (or DEBUG) is set, log each request and response. Off by default.
+ * Sanitizes bodies to avoid logging tokens, passwords, or authorization headers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugLogMiddleware = debugLogMiddleware;
+const config_1 = require("../config");
+const logger_1 = require("../utils/logger");
+const SENSITIVE_KEYS = ["token", "password", "authorization", "cookie", "set-cookie"];
+function sanitize(obj) {
+    if (obj == null)
+        return obj;
+    if (typeof obj !== "object")
+        return obj;
+    if (Array.isArray(obj))
+        return obj.map(sanitize);
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+        const keyLower = k.toLowerCase();
+        if (SENSITIVE_KEYS.some((s) => keyLower.includes(s))) {
+            out[k] = "[REDACTED]";
+        }
+        else {
+            out[k] = sanitize(v);
+        }
+    }
+    return out;
+}
+function safeStringify(obj) {
+    try {
+        const s = sanitize(obj);
+        return typeof s === "object" ? JSON.stringify(s) : String(s);
+    }
+    catch {
+        return "[unserializable]";
+    }
+}
+function debugLogMiddleware(req, res, next) {
+    if (!config_1.config.debug) {
+        next();
+        return;
+    }
+    const method = req.method;
+    const url = req.originalUrl || req.url;
+    const query = Object.keys(req.query).length ? safeStringify(req.query) : undefined;
+    const body = req.body !== undefined && req.body !== null && Object.keys(req.body).length > 0
+        ? safeStringify(req.body)
+        : undefined;
+    logger_1.logger.info("MCP request", {
+        method,
+        url,
+        ...(query && { query }),
+        ...(body && { body }),
+    });
+    let responseLogged = false;
+    const logResponse = (meta) => {
+        if (!responseLogged) {
+            responseLogged = true;
+            logger_1.logger.info("MCP response", { method, url, statusCode: res.statusCode, ...meta });
+        }
+    };
+    res.on("finish", () => {
+        if (!responseLogged) {
+            logger_1.logger.info("MCP response", { method, url, statusCode: res.statusCode });
+        }
+    });
+    const originalJson = res.json.bind(res);
+    res.json = function (body) {
+        logResponse({ body: safeStringify(body) });
+        return originalJson(body);
+    };
+    const originalSend = res.send.bind(res);
+    res.send = function (body) {
+        if (typeof body === "string" && body.length > 0 && body.length < 2000) {
+            logResponse({ bodyPreview: body });
+        }
+        else {
+            logResponse({ bodyLength: typeof body === "string" ? body.length : "[buffer]" });
+        }
+        return originalSend(body);
+    };
+    next();
+}

package/dist/middleware/error.middleware.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Centralized error handling. No stack traces in production.
+ */
+import { Request, Response, NextFunction } from "express";
+export interface ApiError extends Error {
+    status?: number;
+}
+export declare function errorMiddleware(err: ApiError, _req: Request, res: Response, _next: NextFunction): void;

package/dist/middleware/error.middleware.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Centralized error handling. No stack traces in production.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorMiddleware = errorMiddleware;
+const config_1 = require("../config");
+const logger_1 = require("../utils/logger");
+function errorMiddleware(err, _req, res, _next) {
+    const status = err.status ?? 500;
+    const message = err.message ?? "Internal server error";
+    if (config_1.config.nodeEnv === "production") {
+        logger_1.logger.error("Request error", { status, message });
+    }
+    else {
+        logger_1.logger.error("Request error", { status, message, stack: err.stack });
+    }
+    const body = {
+        success: false,
+        message,
+        code: status,
+    };
+    res.status(status).json(body);
+}

package/dist/middleware/validate.middleware.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Zod validation middleware. Runs schema parse and attaches result to request.
+ */
+import { Request, Response, NextFunction } from "express";
+import { ZodSchema } from "zod";
+export declare function validateBody<T>(schema: ZodSchema<T>): (req: Request, res: Response, next: NextFunction) => void;
+export declare function validateQuery<T>(schema: ZodSchema<T>): (req: Request, res: Response, next: NextFunction) => void;

package/dist/middleware/validate.middleware.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Zod validation middleware. Runs schema parse and attaches result to request.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBody = validateBody;
+exports.validateQuery = validateQuery;
+const zod_1 = require("zod");
+function validateBody(schema) {
+    return (req, res, next) => {
+        try {
+            const parsed = schema.parse(req.body);
+            req.body = parsed;
+            next();
+        }
+        catch (e) {
+            if (e instanceof zod_1.ZodError) {
+                const msg = e.errors.map((x) => `${x.path.join(".")}: ${x.message}`).join("; ");
+                res.status(400).json({ success: false, message: msg, code: 400 });
+                return;
+            }
+            next(e);
+        }
+    };
+}
+function validateQuery(schema) {
+    return (req, res, next) => {
+        try {
+            const parsed = schema.parse(req.query);
+            req.query = parsed;
+            next();
+        }
+        catch (e) {
+            if (e instanceof zod_1.ZodError) {
+                const msg = e.errors.map((x) => `${x.path.join(".")}: ${x.message}`).join("; ");
+                res.status(400).json({ success: false, message: msg, code: 400 });
+                return;
+            }
+            next(e);
+        }
+    };
+}

package/dist/routes/analytics.routes.d.ts

@@ -0,0 +1 @@
+export declare const analyticsRoutes: import("express-serve-static-core").Router;

package/dist/routes/analytics.routes.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyticsRoutes = void 0;
+const express_1 = require("express");
+const auth_middleware_1 = require("../middleware/auth.middleware");
+const analytics_controller_1 = require("../controllers/analytics.controller");
+const router = (0, express_1.Router)();
+router.use(auth_middleware_1.authMiddleware);
+router.use(auth_middleware_1.requireAuth);
+router.get("/sessions-per-browser", analytics_controller_1.getSessionsPerBrowser);
+router.get("/sessions-by-build", analytics_controller_1.getSessionsByBuild);
+router.get("/failed-count", analytics_controller_1.getFailedCount);
+router.get("/most-active-project", analytics_controller_1.getMostActiveProject);
+router.get("/most-active-user", analytics_controller_1.getMostActiveUser);
+exports.analyticsRoutes = router;

package/dist/routes/auth.routes.d.ts

@@ -0,0 +1 @@
+export declare const authRoutes: import("express-serve-static-core").Router;

package/dist/routes/auth.routes.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authRoutes = void 0;
+const express_1 = require("express");
+const validate_middleware_1 = require("../middleware/validate.middleware");
+const auth_middleware_1 = require("../middleware/auth.middleware");
+const auth_controller_1 = require("../controllers/auth.controller");
+const auth_device_controller_1 = require("../controllers/auth-device.controller");
+const auth_dto_1 = require("../dto/auth.dto");
+const router = (0, express_1.Router)();
+router.post("/initiate", auth_device_controller_1.initiate);
+router.get("/status", auth_device_controller_1.status);
+router.use(auth_middleware_1.authMiddleware);
+router.post("/login", (0, validate_middleware_1.validateBody)(auth_dto_1.LoginBodySchema), auth_controller_1.login);
+exports.authRoutes = router;

package/dist/routes/browser.routes.d.ts

@@ -0,0 +1 @@
+export declare const browserRoutes: import("express-serve-static-core").Router;

package/dist/routes/browser.routes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browserRoutes = void 0;
+const express_1 = require("express");
+const auth_middleware_1 = require("../middleware/auth.middleware");
+const browser_controller_1 = require("../controllers/browser.controller");
+const router = (0, express_1.Router)();
+router.use(auth_middleware_1.authMiddleware);
+router.use(auth_middleware_1.requireAuth);
+router.get("/", browser_controller_1.listBrowsers);
+exports.browserRoutes = router;

package/dist/routes/device.routes.d.ts

@@ -0,0 +1 @@
+export declare const deviceRoutes: import("express-serve-static-core").Router;

package/dist/routes/device.routes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deviceRoutes = void 0;
+const express_1 = require("express");
+const auth_middleware_1 = require("../middleware/auth.middleware");
+const device_controller_1 = require("../controllers/device.controller");
+const router = (0, express_1.Router)();
+router.use(auth_middleware_1.authMiddleware);
+router.use(auth_middleware_1.requireAuth);
+router.get("/", device_controller_1.listDevices);
+exports.deviceRoutes = router;

package/dist/routes/index.d.ts

@@ -0,0 +1 @@
+export declare const routes: import("express-serve-static-core").Router;

package/dist/routes/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routes = void 0;
+const express_1 = require("express");
+const auth_routes_1 = require("./auth.routes");
+const session_routes_1 = require("./session.routes");
+const browser_routes_1 = require("./browser.routes");
+const device_routes_1 = require("./device.routes");
+const user_routes_1 = require("./user.routes");
+const project_stats_routes_1 = require("./project-stats.routes");
+const upload_routes_1 = require("./upload.routes");
+const analytics_routes_1 = require("./analytics.routes");
+const mcp_routes_1 = require("./mcp.routes");
+const router = (0, express_1.Router)();
+router.use("/auth", auth_routes_1.authRoutes);
+router.use("/sessions", session_routes_1.sessionRoutes);
+router.use("/browsers", browser_routes_1.browserRoutes);
+router.use("/devices", device_routes_1.deviceRoutes);
+router.use("/users", user_routes_1.userRoutes);
+router.use("/projects", project_stats_routes_1.projectStatsRoutes);
+router.use("/apps", upload_routes_1.uploadRoutes);
+router.use("/analytics", analytics_routes_1.analyticsRoutes);
+router.use("/mcp", mcp_routes_1.mcpRoutes);
+router.get("/health", (_req, res) => {
+    res.status(200).json({ success: true, service: "sbox-mcp" });
+});
+exports.routes = router;

package/dist/routes/mcp.routes.d.ts

@@ -0,0 +1,6 @@
+/**
+ * MCP over Streamable HTTP (POST/GET/DELETE /mcp).
+ * Supports Cursor config: "url": "https://sbox.e34.io/mcp"
+ * SDK is required by path so Node resolves the CJS build (same as mcp-server.ts).
+ */
+export declare const mcpRoutes: import("express-serve-static-core").Router;

package/dist/routes/mcp.routes.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * MCP over Streamable HTTP (POST/GET/DELETE /mcp).
+ * Supports Cursor config: "url": "https://sbox.e34.io/mcp"
+ * SDK is required by path so Node resolves the CJS build (same as mcp-server.ts).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpRoutes = void 0;
+const express_1 = require("express");
+const path_1 = __importDefault(require("path"));
+const crypto_1 = require("crypto");
+const index_1 = require("../mcp/tools/index");
+const sdkServerDir = path_1.default.join(__dirname, "..", "..", "node_modules", "@modelcontextprotocol", "sdk", "dist", "cjs", "server");
+const { McpServer } = require(path_1.default.join(sdkServerDir, "mcp.js"));
+const { StreamableHTTPServerTransport } = require(path_1.default.join(sdkServerDir, "streamableHttp.js"));
+const sessionMap = new Map();
+function createSboxMcpServer() {
+    const server = new McpServer({
+        name: "sbox-mcp",
+        version: "1.0.0",
+    });
+    (0, index_1.registerSboxTools)(server);
+    return server;
+}
+const router = (0, express_1.Router)({ mergeParams: true });
+// Handle all methods and paths under /mcp (/, "", or subpaths) so POST /mcp and POST /mcp/ both work
+const streamableHandler = async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    if (sessionId) {
+        const entry = sessionMap.get(sessionId);
+        if (!entry) {
+            res.status(404).json({
+                jsonrpc: "2.0",
+                error: { code: -32001, message: "Session not found" },
+                id: null,
+            });
+            return;
+        }
+        await entry.transport.handleRequest(req, res, req.body);
+        return;
+    }
+    // New session: only POST with initialize is valid
+    if (req.method !== "POST") {
+        res.status(400).json({
+            jsonrpc: "2.0",
+            error: { code: -32000, message: "Bad Request: Mcp-Session-Id header is required" },
+            id: null,
+        });
+        return;
+    }
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => (0, crypto_1.randomUUID)(),
+        onsessioninitialized: (id) => {
+            sessionMap.set(id, { server, transport });
+        },
+        onsessionclosed: (id) => {
+            sessionMap.delete(id);
+        },
+    });
+    const server = createSboxMcpServer();
+    await server.connect(transport);
+    await transport.handleRequest(req, res, req.body);
+};
+router.all("/", streamableHandler);
+// When client sends POST /mcp (no trailing slash), some setups pass path as "" to the mounted router
+router.use(streamableHandler);
+exports.mcpRoutes = router;

package/dist/routes/project-stats.routes.d.ts

@@ -0,0 +1 @@
+export declare const projectStatsRoutes: import("express-serve-static-core").Router;

package/dist/routes/project-stats.routes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectStatsRoutes = void 0;
+const express_1 = require("express");
+const auth_middleware_1 = require("../middleware/auth.middleware");
+const project_stats_controller_1 = require("../controllers/project-stats.controller");
+const router = (0, express_1.Router)();
+router.use(auth_middleware_1.authMiddleware);
+router.use(auth_middleware_1.requireAuth);
+router.get("/sessions-per-project", project_stats_controller_1.getSessionsPerProject);
+exports.projectStatsRoutes = router;

package/dist/routes/session.routes.d.ts

@@ -0,0 +1 @@
+export declare const sessionRoutes: import("express-serve-static-core").Router;

package/dist/routes/session.routes.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionRoutes = void 0;
+const express_1 = require("express");
+const auth_middleware_1 = require("../middleware/auth.middleware");
+const validate_middleware_1 = require("../middleware/validate.middleware");
+const session_controller_1 = require("../controllers/session.controller");
+const session_dto_1 = require("../dto/session.dto");
+const router = (0, express_1.Router)();
+router.use(auth_middleware_1.authMiddleware);
+router.use(auth_middleware_1.requireAuth);
+router.get("/", session_controller_1.listSessions);
+router.get("/:ekey", session_controller_1.getSessionDetail);
+router.put("/status", (0, validate_middleware_1.validateBody)(session_dto_1.UpdateSessionStatusBodySchema), session_controller_1.updateSessionStatus);
+router.delete("/", (req, res, next) => {
+    if (!req.query.sessionId) {
+        res.status(400).json({ success: false, message: "sessionId required", code: 400 });
+        return;
+    }
+    next();
+}, session_controller_1.deleteSession);
+router.post("/manual", session_controller_1.startManualSession);
+exports.sessionRoutes = router;

package/dist/routes/upload.routes.d.ts

@@ -0,0 +1 @@
+export declare const uploadRoutes: import("express-serve-static-core").Router;

package/dist/routes/upload.routes.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadRoutes = void 0;
+const express_1 = require("express");
+const multer_1 = __importDefault(require("multer"));
+const auth_middleware_1 = require("../middleware/auth.middleware");
+const upload_controller_1 = require("../controllers/upload.controller");
+const MAX_FILE_SIZE = 200 * 1024 * 1024; // 200MB
+const upload = (0, multer_1.default)({
+    storage: multer_1.default.memoryStorage(),
+    limits: { fileSize: MAX_FILE_SIZE },
+});
+const router = (0, express_1.Router)();
+router.use(auth_middleware_1.authMiddleware);
+router.use(auth_middleware_1.requireAuth);
+router.post("/upload", upload.single("file"), upload_controller_1.uploadMobileApp);
+exports.uploadRoutes = router;

package/dist/routes/user.routes.d.ts

@@ -0,0 +1 @@
+export declare const userRoutes: import("express-serve-static-core").Router;

package/dist/routes/user.routes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userRoutes = void 0;
+const express_1 = require("express");
+const auth_middleware_1 = require("../middleware/auth.middleware");
+const user_controller_1 = require("../controllers/user.controller");
+const router = (0, express_1.Router)();
+router.use(auth_middleware_1.authMiddleware);
+router.use(auth_middleware_1.requireAuth);
+router.get("/active", user_controller_1.getActiveUsers);
+exports.userRoutes = router;

package/dist/server.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const app_1 = __importDefault(require("./app"));
+const config_1 = require("./config");
+const logger_1 = require("./utils/logger");
+const server = app_1.default.listen(config_1.config.port, () => {
+    logger_1.logger.info("SBOX MCP server listening", { port: config_1.config.port, env: config_1.config.nodeEnv, debug: config_1.config.debug });
+});
+process.on("SIGTERM", () => {
+    server.close(() => {
+        logger_1.logger.info("SBOX MCP server closed");
+        process.exit(0);
+    });
+});

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

@@ -0,0 +1,88 @@
+/**
+ * Analytics service: sessions per browser, by build, failed count, most active project/user.
+ * Time range can be in hours, minutes, or days.
+ */
+import type { StatsAdapter } from "../adapters/stats.adapter";
+import type { TimeRange } from "../utils/time-range";
+export interface SessionsPerBrowserDto {
+    browser: string;
+    version: string;
+    count: number;
+}
+export interface SessionsByBuildDto {
+    buildName: string;
+    sessionCount: number;
+}
+export interface TestNameCountDto {
+    testName: string;
+    count: number;
+}
+export interface AnalyticsService {
+    totalTests(token: string, days: number): Promise<{
+        success: true;
+        total: number;
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+    sessionsPerBrowser(token: string, timeRange: TimeRange): Promise<{
+        success: true;
+        data: SessionsPerBrowserDto[];
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+    sessionsByBuild(token: string, timeRange: TimeRange): Promise<{
+        success: true;
+        data: SessionsByBuildDto[];
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+    failedCount(token: string, timeRange: TimeRange): Promise<{
+        success: true;
+        count: number;
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+    mostActiveProject(token: string, timeRange: TimeRange): Promise<{
+        success: true;
+        projectName: string;
+        count: number;
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+    mostActiveUser(token: string, timeRange: TimeRange): Promise<{
+        success: true;
+        userName: string;
+        count: number;
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+    testsPerTestName(token: string, timeRange: TimeRange): Promise<{
+        success: true;
+        data: TestNameCountDto[];
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+    manualTestsPerTestName(token: string, timeRange: TimeRange): Promise<{
+        success: true;
+        data: TestNameCountDto[];
+    } | {
+        success: false;
+        status: number;
+        message: string;
+    }>;
+}
+export declare function createAnalyticsService(statsAdapter: StatsAdapter): AnalyticsService;

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 };
+        },
+    };
+}