@seleniumbox/sbox-mcp 1.0.0

package/PUBLISHING.md

@@ -0,0 +1,115 @@
+# Publishing @seleniumbox/sbox-mcp
+
+Guide for publishing the package to npm.
+
+## Prerequisites
+
+- npm account with access to the **@seleniumbox** scope.
+- Node.js 18+.
+
+## Step 1: Log in to npm
+
+```bash
+npm login
+```
+
+Use your npm credentials. For 2FA, have your one-time password ready if enabled.
+
+## Step 2: Bump version
+
+From the **modules/mcp** directory:
+
+```bash
+npm version patch   # 0.1.0 → 0.1.1 (bug fixes)
+npm version minor   # 0.1.0 → 0.2.0 (new features, backward compatible)
+npm version major   # 0.1.0 → 1.0.0 (breaking changes)
+```
+
+This updates `package.json` and creates a git commit and tag (e.g. `v0.1.1`).
+
+## Step 3: Publish to npm
+
+Build a clean dist (includes shebang in the bin entry for npx):
+
+```bash
+npm run rebuild
+npm publish --access public
+```
+
+**Scoped packages** (`@seleniumbox/sbox-mcp`) are private by default. `--access public` makes the package visible to everyone.
+
+**First-time publish** for this package:
+
+- Ensure `package.json` has `"name": "@seleniumbox/sbox-mcp"`, `version`, `description`, `license`, and `repository`.
+- Run `npm publish --access public` once; subsequent publishes do not require `--access` unless you change visibility.
+
+## Step 4: Tag release in Git
+
+If you use a monorepo and want a tag that includes the module path:
+
+```bash
+git tag -a sbox-mcp/v0.1.1 -m "sbox-mcp 0.1.1"
+git push origin sbox-mcp/v0.1.1
+```
+
+Or rely on the default tag created by `npm version` (e.g. `v0.1.1`) and push it:
+
+```bash
+git push origin v0.1.1
+```
+
+## Step 5: Update changelog
+
+- Add an entry under a new version heading (e.g. `## [0.1.1]`) in the repo’s main `CHANGELOG.md` or in `modules/mcp/CHANGELOG.md` if you keep one for this package.
+- Include: date, list of changes (fixes, features, breaking changes).
+
+## Testing locally before publishing
+
+### Using `npm link`
+
+From **modules/mcp**:
+
+```bash
+npm run build
+npm link
+```
+
+From another project or a test directory:
+
+```bash
+npm link @seleniumbox/sbox-mcp
+npx sbox-mcp
+```
+
+Or run the linked binary directly:
+
+```bash
+sbox-mcp
+```
+
+(Ensure the global `node_modules/.bin` is in your `PATH`.)
+
+### Using `npx` with the local directory
+
+From the repo root or any directory that can see the built package:
+
+```bash
+cd modules/mcp && npm run build && npx .
+```
+
+Or from **modules/mcp** after `npm run build`:
+
+```bash
+npx .
+```
+
+This runs the local `dist/index.js` as the MCP server so you can verify behavior before publishing.
+
+## Summary checklist
+
+1. `npm login`
+2. `npm version patch|minor|major`
+3. `npm publish --access public`
+4. `git push` (and push tags if desired)
+5. Update changelog
+6. Optionally test with `npx -y @seleniumbox/sbox-mcp@latest` after publish

package/README.md

@@ -0,0 +1,79 @@
+# @seleniumbox/sbox-mcp
+
+Model Context Protocol (MCP) server for **Selenium Box (SBOX)**. Exposes SBOX APIs to AI-assisted IDEs (Cursor, Windsurf, IntelliJ) as MCP tools. Runs **locally** on your machine via `npx`—no Docker required.
+
+## Installation
+
+No install step. Your IDE runs the server via **npx** (same pattern as TestingBot MCP):
+
+```bash
+npx -y @seleniumbox/sbox-mcp@latest
+```
+
+## IDE configuration
+
+### Cursor / Windsurf
+
+Add to your MCP settings (e.g. `.cursor/mcp.json` or Cursor Settings → MCP):
+
+```json
+{
+  "mcpServers": {
+    "sbox": {
+      "command": "npx",
+      "args": ["-y", "@seleniumbox/sbox-mcp@latest"],
+      "env": {
+        "SBOX_API": "http://localhost:4444"
+      }
+    }
+  }
+}
+```
+
+- **SBOX_API** – Base URL of your SBOX hub (no trailing slash). Default: `http://localhost:4444`.
+
+Then restart Cursor or reload MCP.
+
+## Required environment variables
+
+| Variable    | Default                   | Description                          |
+|------------|---------------------------|--------------------------------------|
+| `SBOX_API` | `http://localhost:4444`   | Base URL of the SBOX hub (no slash). |
+
+Optional:
+
+| Variable                 | Default     | Description                                                                 |
+|-------------------------|-------------|-----------------------------------------------------------------------------|
+| `MCP_DEBUG` or `DEBUG`   | —           | Set to `1` or `true` to log incoming MCP and outbound SBOX API request/response (sensitive fields redacted). |
+| `MCP_REQUEST_TIMEOUT_MS`| `30000`     | Timeout for outbound SBOX API requests.                                    |
+| `SBOX_MCP_TOKEN_FILE`   | see below   | Override path for the persisted session token file (default: `~/.sbox-mcp/token`). |
+| `SBOX_ALLOW_INSECURE_SSL` | (default: skip verification) | Set to `0` or `false` to verify TLS certificates; unset or `1`/`true` skips verification (default). |
+
+## Token cache
+
+After you log in via **sbox_open_login**, the session token is stored in memory and **on disk** so it survives MCP process restarts (e.g. when the IDE starts a new process per prompt). Default location: `~/.sbox-mcp/token`. The cache directory is created with mode `0700` and the token file with `0600`. Set `SBOX_MCP_TOKEN_FILE` to use a different path (only the token file; the directory is inferred for `last_poll_id`). If an API call returns 401 or “invalid token”, the cache is cleared so the next run will prompt for login again.
+
+## Authentication flow
+
+1. User asks the AI to log in to SBOX (e.g. “authenticate with SBOX”).
+2. The **sbox_open_login** tool runs:
+   - Checks that the MCP add-on is enabled on the hub.
+   - Generates a unique session id, opens the login URL in your default browser (or returns `auth_url` so the IDE can open it).
+3. You sign in on the SBOX hub (local, LDAP, or OIDC).
+4. The hub stores the token by session id; MCP polls for it and caches it.
+5. Subsequent SBOX tools use the cached token automatically.
+
+**Device + Poll**: No callback server on your machine. The hub holds the token and MCP retrieves it by polling. Same contract as before; only distribution is local.
+
+## SBOX_API usage
+
+- All MCP tools that call the hub use `SBOX_API` (or `SBOX_API_BASE_URL`) to build URLs, e.g. `{SBOX_API}/e34/api/...`.
+- The login URL shown to you is `{SBOX_API}/ui/login?mcp_poll_id=...`. Use the same base URL in your browser as the hub (e.g. `http://localhost:4444` for a local hub).
+
+## Hub requirements
+
+- **MCP add-on** enabled (license flag `E34_MCP`).
+
+## License
+
+Apache-2.0

package/dist/adapters/auth.adapter.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Adapter for SBOX authentication. Calls POST /authenticate and GET /user/session.
+ * No business logic; no password hashing (handled by backend).
+ */
+export interface CredentialPayload {
+    username: string;
+    password: string;
+}
+export interface UserSessionApi {
+    token: string;
+    principal: {
+        userId?: string;
+        fullname?: string;
+        realm?: {
+            id?: string;
+        };
+    };
+}
+export interface McpPollResponse {
+    token?: string;
+}
+export interface McpEnabledResponse {
+    enabled?: boolean;
+}
+export interface AuthAdapter {
+    isMcpAddonEnabled(): Promise<boolean>;
+    login(payload: CredentialPayload): Promise<{
+        status: number;
+        data: UserSessionApi | {
+            success: false;
+            message: string;
+        };
+    }>;
+    validateSession(token: string): Promise<{
+        status: number;
+        data: UserSessionApi | {
+            success: false;
+            message: string;
+        };
+    }>;
+    pollToken(pollId: string): Promise<{
+        status: number;
+        data: McpPollResponse;
+    }>;
+}
+export declare const authAdapter: AuthAdapter;

package/dist/adapters/auth.adapter.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Adapter for SBOX authentication. Calls POST /authenticate and GET /user/session.
+ * No business logic; no password hashing (handled by backend).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authAdapter = void 0;
+const sbox_api_client_1 = require("./sbox-api.client");
+const config_1 = require("../config");
+const logger_1 = require("../utils/logger");
+async function isMcpAddonEnabled() {
+    const url = `${config_1.config.sboxApiBaseUrl}${config_1.config.sboxApiPrefix}/mcp/enabled`;
+    logger_1.logger.info("MCP add-on check: requesting", { url });
+    try {
+        const { data, status } = await (0, sbox_api_client_1.getPublic)("mcp/enabled");
+        const enabled = status === 200 && typeof data?.enabled === "boolean" && data.enabled === true;
+        if (!enabled) {
+            logger_1.logger.info("MCP add-on check: hub did not return enabled=true", {
+                url,
+                status,
+                responseBody: typeof data === "object" ? data : String(data),
+            });
+        }
+        return enabled;
+    }
+    catch (err) {
+        logger_1.logger.error("MCP add-on check: request failed", {
+            url,
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return false;
+    }
+}
+async function login(payload) {
+    const { data, status } = await (0, sbox_api_client_1.post)("authenticate", payload);
+    if (status !== 200) {
+        const msg = (0, sbox_api_client_1.isSboxError)(data) ? data.message : "Login failed";
+        return { status, data: { success: false, message: msg } };
+    }
+    return { status, data: data };
+}
+async function validateSession(token) {
+    const { data, status } = await (0, sbox_api_client_1.get)("user/session", token);
+    if (status !== 200) {
+        const msg = (0, sbox_api_client_1.isSboxError)(data) ? data.message : "Invalid or expired token";
+        return { status, data: { success: false, message: msg } };
+    }
+    return { status, data: data };
+}
+async function pollToken(pollId) {
+    const { data, status } = await (0, sbox_api_client_1.get)("mcp/poll?poll_id=" + encodeURIComponent(pollId), null);
+    return { status, data: data ?? {} };
+}
+exports.authAdapter = { isMcpAddonEnabled, login, validateSession, pollToken };

package/dist/adapters/browser.adapter.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Adapter for SBOX browser APIs. Calls /browser/details, /executors, /playwright.
+ * No business logic; only HTTP and response typing.
+ */
+export interface ImageInfoRaw {
+    name?: string;
+    tags?: string[];
+}
+export interface ExecutorDtoRaw {
+    id?: string;
+    type?: string;
+    capabilities?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/** GET /e34/api/playwright returns list of { version, chromium, webkit, firefox } */
+export interface PlaywrightVersionRaw {
+    version?: string;
+    chromium?: string;
+    webkit?: string;
+    firefox?: string;
+    [key: string]: unknown;
+}
+export interface BrowserAdapter {
+    getBrowserVersions(name: string, token: string): Promise<{
+        status: number;
+        name: string;
+        versions: string[];
+        error?: string;
+    }>;
+    getExecutors(token: string): Promise<{
+        status: number;
+        executors: ExecutorDtoRaw[];
+        error?: string;
+    }>;
+    getPlaywrightVersions(token: string): Promise<{
+        status: number;
+        versions: PlaywrightVersionRaw[];
+        error?: string;
+    }>;
+}
+declare const BROWSER_NAMES: string[];
+export declare const browserAdapter: BrowserAdapter;
+export { BROWSER_NAMES };

package/dist/adapters/browser.adapter.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Adapter for SBOX browser APIs. Calls /browser/details, /executors, /playwright.
+ * No business logic; only HTTP and response typing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BROWSER_NAMES = exports.browserAdapter = void 0;
+const sbox_api_client_1 = require("./sbox-api.client");
+const BROWSER_NAMES = ["chrome", "firefox", "firefox-esr", "MicrosoftEdge", "internet explorer", "safari", "webkit"];
+exports.BROWSER_NAMES = BROWSER_NAMES;
+async function getBrowserVersions(name, token) {
+    const { data, status } = await (0, sbox_api_client_1.get)(`browser/details?name=${encodeURIComponent(name)}`, token);
+    if (status !== 200) {
+        const msg = (0, sbox_api_client_1.isSboxError)(data) ? data.message : "Failed to get browser versions";
+        return { status, name, versions: [], error: msg };
+    }
+    const raw = data;
+    const tags = Array.isArray(raw.tags) ? raw.tags : [];
+    return { status, name: raw.name ?? name, versions: tags };
+}
+async function getExecutors(token) {
+    const { data, status } = await (0, sbox_api_client_1.get)("executors", token);
+    if (status !== 200) {
+        const msg = (0, sbox_api_client_1.isSboxError)(data) ? data.message : "Failed to get executors";
+        return { status, executors: [], error: msg };
+    }
+    const list = Array.isArray(data) ? data : [];
+    return { status, executors: list };
+}
+async function getPlaywrightVersions(token) {
+    const { data, status } = await (0, sbox_api_client_1.get)("playwright", token);
+    if (status !== 200) {
+        const msg = (0, sbox_api_client_1.isSboxError)(data) ? data.message : "Playwright is not enabled or failed to get versions";
+        return { status, versions: [], error: msg };
+    }
+    const list = Array.isArray(data) ? data : [];
+    return { status, versions: list };
+}
+exports.browserAdapter = { getBrowserVersions, getExecutors, getPlaywrightVersions };

package/dist/adapters/device.adapter.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Adapter for SBOX device APIs. Calls mobile/ios/devices, mobile/android/devices, mobileweb/devices.
+ * No business logic; only HTTP and response typing.
+ */
+/** Android API: GET /e34/api/mobile/android/devices */
+export interface AndroidDeviceRaw {
+    avdName?: string;
+    deviceName?: string;
+    completeDeviceName?: string;
+    supportedPlatformVersions?: string[];
+    [key: string]: unknown;
+}
+/** iOS API: GET /e34/api/mobile/ios/devices (IOSDeviceAPI: deviceName + getIOSSDK list) */
+export interface IOSDeviceRaw {
+    deviceName?: string;
+    /** List of supported SDKs (each has name, safariVersion). Backend may serialize as iosSDK, iossdks, or IOSSDK. */
+    iosSDK?: Array<{
+        name?: string;
+        safariVersion?: string;
+    }>;
+    iossdks?: Array<{
+        name?: string;
+        safariVersion?: string;
+    }>;
+    IOSSDK?: Array<{
+        name?: string;
+        safariVersion?: string;
+    }>;
+    [key: string]: unknown;
+}
+/** Generic device raw (mobile web may use name, os, version) */
+export interface DeviceRaw {
+    name?: string;
+    deviceName?: string;
+    completeDeviceName?: string;
+    avdName?: string;
+    supportedPlatformVersions?: string[];
+    os?: string;
+    version?: string;
+    available?: boolean;
+    [key: string]: unknown;
+}
+export interface DeviceAdapter {
+    getIosDevices(token: string): Promise<{
+        status: number;
+        devices: IOSDeviceRaw[];
+        error?: string;
+    }>;
+    getAndroidDevices(token: string): Promise<{
+        status: number;
+        devices: AndroidDeviceRaw[];
+        error?: string;
+    }>;
+    getMobileWebDevices(token: string): Promise<{
+        status: number;
+        devices: DeviceRaw[];
+        error?: string;
+    }>;
+}
+export declare const deviceAdapter: DeviceAdapter;

package/dist/adapters/device.adapter.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Adapter for SBOX device APIs. Calls mobile/ios/devices, mobile/android/devices, mobileweb/devices.
+ * No business logic; only HTTP and response typing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deviceAdapter = void 0;
+const sbox_api_client_1 = require("./sbox-api.client");
+async function getIosDevices(token) {
+    const { data, status } = await (0, sbox_api_client_1.get)("mobile/ios/devices", token);
+    if (status !== 200) {
+        const msg = (0, sbox_api_client_1.isSboxError)(data) ? data.message : "Failed to get iOS devices";
+        return { status, devices: [], error: msg };
+    }
+    const list = Array.isArray(data) ? data : [];
+    return { status, devices: list };
+}
+async function getAndroidDevices(token) {
+    const { data, status } = await (0, sbox_api_client_1.get)("mobile/android/devices", token);
+    if (status !== 200) {
+        const msg = (0, sbox_api_client_1.isSboxError)(data) ? data.message : "Failed to get Android devices";
+        return { status, devices: [], error: msg };
+    }
+    const list = Array.isArray(data) ? data : [];
+    return { status, devices: list };
+}
+async function getMobileWebDevices(token) {
+    const { data, status } = await (0, sbox_api_client_1.get)("mobileweb/devices", token);
+    if (status !== 200) {
+        const msg = (0, sbox_api_client_1.isSboxError)(data) ? data.message : "Failed to get mobile web devices";
+        return { status, devices: [], error: msg };
+    }
+    const list = Array.isArray(data) ? data : [];
+    return { status, devices: list };
+}
+exports.deviceAdapter = {
+    getIosDevices,
+    getAndroidDevices,
+    getMobileWebDevices,
+};

package/dist/adapters/diagnostics.adapter.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Adapter for SBOX Diagnostics Dashboard APIs.
+ * Endpoints: cpu-usage-per-node, tests/queued/hourly, nodes/active-tests, queue/waiting-time, tests-active-graph, tests/starting/stats, executors.
+ */
+export interface CpuUsagePerNodeRaw {
+    node?: string;
+    avg_cpu?: number;
+    timestamp?: string;
+}
+export interface TestsQueuedHourlyRaw {
+    timestamp?: string;
+    avg_total?: number;
+    max_total?: number;
+}
+export interface NodesActiveTestsRaw {
+    timestamp?: string;
+    average_total?: number;
+}
+export interface QueueWaitingTimeRaw {
+    timestamp?: string;
+    browsers?: Array<{
+        avg_duration?: number;
+        max_duration?: number;
+    }>;
+}
+export interface TestsActiveGraphRaw {
+    timestamp?: string;
+    avg_total?: number;
+    node?: string;
+}
+export interface TestsStartingStatsRaw {
+    timestamp?: string;
+    node?: string;
+    avg_total?: number;
+}
+export interface DiagnosticsAdapter {
+    getExecutorsCount(token: string): Promise<{
+        status: number;
+        count: number;
+        error?: string;
+    }>;
+    getCpuUsagePerNode(token: string, days: number): Promise<{
+        status: number;
+        items: CpuUsagePerNodeRaw[];
+        error?: string;
+    }>;
+    getTestsQueuedHourly(token: string, days: number): Promise<{
+        status: number;
+        items: TestsQueuedHourlyRaw[];
+        error?: string;
+    }>;
+    getNodesActiveTests(token: string, days: number): Promise<{
+        status: number;
+        items: NodesActiveTestsRaw[];
+        error?: string;
+    }>;
+    getQueueWaitingTime(token: string, days: number): Promise<{
+        status: number;
+        items: QueueWaitingTimeRaw[];
+        error?: string;
+    }>;
+    getTestsActiveGraph(token: string, days: number): Promise<{
+        status: number;
+        items: TestsActiveGraphRaw[];
+        error?: string;
+    }>;
+    getTestsStartingStats(token: string, days: number): Promise<{
+        status: number;
+        items: TestsStartingStatsRaw[];
+        error?: string;
+    }>;
+}
+export declare const diagnosticsAdapter: DiagnosticsAdapter;

package/dist/adapters/diagnostics.adapter.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Adapter for SBOX Diagnostics Dashboard APIs.
+ * Endpoints: cpu-usage-per-node, tests/queued/hourly, nodes/active-tests, queue/waiting-time, tests-active-graph, tests/starting/stats, executors.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diagnosticsAdapter = void 0;
+const sbox_api_client_1 = require("./sbox-api.client");
+function clampDays(days) {
+    return Math.max(7, Math.min(365, days));
+}
+async function getExecutorsCount(token) {
+    const { data, status } = await (0, sbox_api_client_1.get)("executors", token);
+    if (status !== 200) {
+        const msg = (0, sbox_api_client_1.isSboxError)(data) ? data.message : "Failed to get executors";
+        return { status, count: 0, error: msg };
+    }
+    const list = Array.isArray(data) ? data : [];
+    return { status, count: list.length };
+}
+async function getCpuUsagePerNode(token, days) {
+    const d = clampDays(days);
+    const path = `cpu-usage-per-node?days=${d}`;
+    const { data, status } = await (0, sbox_api_client_1.get)(path, token);
+    if (status !== 200) {
+        const msg = (0, sbox_api_client_1.isSboxError)(data) ? data.message : "Failed to get CPU usage per node";
+        return { status, items: [], error: msg };
+    }
+    return { status, items: Array.isArray(data) ? data : [] };
+}
+async function getTestsQueuedHourly(token, days) {
+    const d = clampDays(days);
+    const path = `tests/queued/hourly?days=${d}`;
+    const { data, status } = await (0, sbox_api_client_1.get)(path, token);
+    if (status !== 200) {
+        const msg = (0, sbox_api_client_1.isSboxError)(data) ? data.message : "Failed to get tests queued hourly";
+        return { status, items: [], error: msg };
+    }
+    return { status, items: Array.isArray(data) ? data : [] };
+}
+async function getNodesActiveTests(token, days) {
+    const d = clampDays(days);
+    const path = `nodes/active-tests?days=${d}`;
+    const { data, status } = await (0, sbox_api_client_1.get)(path, token);
+    if (status !== 200) {
+        const msg = (0, sbox_api_client_1.isSboxError)(data) ? data.message : "Failed to get nodes active tests";
+        return { status, items: [], error: msg };
+    }
+    return { status, items: Array.isArray(data) ? data : [] };
+}
+async function getQueueWaitingTime(token, days) {
+    const d = clampDays(days);
+    const path = `queue/waiting-time?days=${d}`;
+    const { data, status } = await (0, sbox_api_client_1.get)(path, token);
+    if (status !== 200) {
+        const msg = (0, sbox_api_client_1.isSboxError)(data) ? data.message : "Failed to get queue waiting time";
+        return { status, items: [], error: msg };
+    }
+    return { status, items: Array.isArray(data) ? data : [] };
+}
+async function getTestsActiveGraph(token, days) {
+    const d = clampDays(days);
+    const path = `tests-active-graph?days=${d}`;
+    const { data, status } = await (0, sbox_api_client_1.get)(path, token);
+    if (status !== 200) {
+        const msg = (0, sbox_api_client_1.isSboxError)(data) ? data.message : "Failed to get tests active graph";
+        return { status, items: [], error: msg };
+    }
+    return { status, items: Array.isArray(data) ? data : [] };
+}
+async function getTestsStartingStats(token, days) {
+    const d = clampDays(days);
+    const path = `tests/starting/stats?days=${d}`;
+    const { data, status } = await (0, sbox_api_client_1.get)(path, token);
+    if (status !== 200) {
+        const msg = (0, sbox_api_client_1.isSboxError)(data) ? data.message : "Failed to get tests starting stats";
+        return { status, items: [], error: msg };
+    }
+    return { status, items: Array.isArray(data) ? data : [] };
+}
+exports.diagnosticsAdapter = {
+    getExecutorsCount,
+    getCpuUsagePerNode,
+    getTestsQueuedHourly,
+    getNodesActiveTests,
+    getQueueWaitingTime,
+    getTestsActiveGraph,
+    getTestsStartingStats,
+};

package/dist/adapters/index.d.ts

@@ -0,0 +1,16 @@
+export { authAdapter } from "./auth.adapter";
+export type { AuthAdapter, UserSessionApi } from "./auth.adapter";
+export { sessionAdapter } from "./session.adapter";
+export type { SessionAdapter, ESSessionDataRaw } from "./session.adapter";
+export { browserAdapter, BROWSER_NAMES } from "./browser.adapter";
+export type { BrowserAdapter } from "./browser.adapter";
+export { deviceAdapter } from "./device.adapter";
+export type { DeviceAdapter } from "./device.adapter";
+export { projectAdapter } from "./project.adapter";
+export type { ProjectAdapter } from "./project.adapter";
+export { userAdapter } from "./user.adapter";
+export type { UserAdapter } from "./user.adapter";
+export { statsAdapter } from "./stats.adapter";
+export type { StatsAdapter } from "./stats.adapter";
+export { uploadAdapter } from "./upload.adapter";
+export type { UploadAdapter } from "./upload.adapter";

package/dist/adapters/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadAdapter = exports.statsAdapter = exports.userAdapter = exports.projectAdapter = exports.deviceAdapter = exports.BROWSER_NAMES = exports.browserAdapter = exports.sessionAdapter = exports.authAdapter = void 0;
+var auth_adapter_1 = require("./auth.adapter");
+Object.defineProperty(exports, "authAdapter", { enumerable: true, get: function () { return auth_adapter_1.authAdapter; } });
+var session_adapter_1 = require("./session.adapter");
+Object.defineProperty(exports, "sessionAdapter", { enumerable: true, get: function () { return session_adapter_1.sessionAdapter; } });
+var browser_adapter_1 = require("./browser.adapter");
+Object.defineProperty(exports, "browserAdapter", { enumerable: true, get: function () { return browser_adapter_1.browserAdapter; } });
+Object.defineProperty(exports, "BROWSER_NAMES", { enumerable: true, get: function () { return browser_adapter_1.BROWSER_NAMES; } });
+var device_adapter_1 = require("./device.adapter");
+Object.defineProperty(exports, "deviceAdapter", { enumerable: true, get: function () { return device_adapter_1.deviceAdapter; } });
+var project_adapter_1 = require("./project.adapter");
+Object.defineProperty(exports, "projectAdapter", { enumerable: true, get: function () { return project_adapter_1.projectAdapter; } });
+var user_adapter_1 = require("./user.adapter");
+Object.defineProperty(exports, "userAdapter", { enumerable: true, get: function () { return user_adapter_1.userAdapter; } });
+var stats_adapter_1 = require("./stats.adapter");
+Object.defineProperty(exports, "statsAdapter", { enumerable: true, get: function () { return stats_adapter_1.statsAdapter; } });
+var upload_adapter_1 = require("./upload.adapter");
+Object.defineProperty(exports, "uploadAdapter", { enumerable: true, get: function () { return upload_adapter_1.uploadAdapter; } });