@shibbirweb/mcp-db-read-only 0.1.0

package/dist/connections/ConnectionUrlParser.js

@@ -0,0 +1,195 @@
+import { EngineCatalog } from "../domain/Engine.js";
+import { InvalidConnectionUrlError } from "../errors/InvalidConnectionUrlError.js";
+/**
+ * Parses a connection URL for any supported engine into target fields.
+ *
+ * Hand-written rather than delegated to the WHATWG `URL` class, which cannot
+ * parse the one URL shape this server most needs to accept: a MongoDB replica
+ * set, `mongodb://a:27017,b:27017/app`, whose comma-separated authority is not
+ * a valid host to `URL` and throws. It also cannot express a SQLite path.
+ * Since one engine needed a custom parser, every engine uses the same one, so
+ * the rules for credentials, ports and options are identical everywhere.
+ *
+ * Nothing thrown from here contains the URL. See InvalidConnectionUrlError.
+ */
+export class ConnectionUrlParser {
+    static SCHEME = /^([A-Za-z][A-Za-z0-9+.-]*):([\s\S]*)$/;
+    /**
+     * Query parameters that are credentials, kept apart so they never reach a
+     * displayed or logged string. Matched loosely on purpose: a false positive
+     * only hides a harmless option from `list_connections`, while a false
+     * negative prints a secret.
+     */
+    static SECRET_OPTION = /(pass|secret|token|api[_-]?key|credential)/i;
+    parse(url) {
+        const match = ConnectionUrlParser.SCHEME.exec(url.trim());
+        if (!match) {
+            throw new InvalidConnectionUrlError(`expected <scheme>://..., with one of: ${EngineCatalog.schemeNames().join(", ")}.`);
+        }
+        const schemeName = match[1].toLowerCase();
+        const found = EngineCatalog.findScheme(schemeName);
+        if (!found) {
+            throw new InvalidConnectionUrlError(`unsupported scheme "${schemeName}". Supported: ${EngineCatalog.schemeNames().join(", ")}.`);
+        }
+        if (found.engine.engine === "sqlite") {
+            return this.parseSqlite(match[2]);
+        }
+        return this.parseNetworked(match[2], found.engine, found.scheme);
+    }
+    /**
+     * `sqlite:///abs/path.db`, `sqlite://relative.db` and `sqlite:relative.db`
+     * all name a file. Everything after the scheme up to `?` is the path, so a
+     * path containing `@` or `:` is not misread as credentials or a port.
+     */
+    parseSqlite(rest) {
+        const withoutSlashes = rest.startsWith("//") ? rest.slice(2) : rest;
+        const queryAt = withoutSlashes.indexOf("?");
+        const rawPath = queryAt === -1 ? withoutSlashes : withoutSlashes.slice(0, queryAt);
+        const query = queryAt === -1 ? "" : withoutSlashes.slice(queryAt + 1);
+        const path = this.decode(rawPath, "the file path");
+        if (!path) {
+            throw new InvalidConnectionUrlError("a sqlite URL needs a file path, e.g. sqlite:///data/app.db.");
+        }
+        // An in-memory database opened read-only is empty and always will be, so
+        // accepting it would only produce a connection that can never show
+        // anything.
+        if (path === ":memory:") {
+            throw new InvalidConnectionUrlError("an in-memory SQLite database is always empty when read-only.");
+        }
+        const { options, secretOptions } = this.parseQuery(query);
+        return {
+            engine: "sqlite",
+            scheme: "sqlite",
+            hosts: [],
+            user: "",
+            password: "",
+            database: path,
+            options,
+            secretOptions,
+        };
+    }
+    /**
+     * `scheme://[user[:password]@]host[:port][,host[:port]...][/database][?options]`
+     *
+     * The authority ends at the first `/`, `?` or `#`, as RFC 3986 says, so a
+     * password containing any of those must be percent-encoded. That is why the
+     * connect tool and DB_PROFILES also accept the password separately.
+     */
+    parseNetworked(rest, engine, scheme) {
+        if (!rest.startsWith("//")) {
+            throw new InvalidConnectionUrlError(`expected "${scheme.name}://" followed by a host.`);
+        }
+        const remainder = rest.slice(2);
+        const authorityEnd = this.firstIndexOf(remainder, ["/", "?", "#"]);
+        const authority = authorityEnd === -1 ? remainder : remainder.slice(0, authorityEnd);
+        const tail = (authorityEnd === -1 ? "" : remainder.slice(authorityEnd)).split("#")[0];
+        const queryAt = tail.indexOf("?");
+        const path = queryAt === -1 ? tail : tail.slice(0, queryAt);
+        const query = queryAt === -1 ? "" : tail.slice(queryAt + 1);
+        // lastIndexOf, so an unencoded "@" inside a password still splits at the
+        // real separator, the one immediately before the host.
+        const at = authority.lastIndexOf("@");
+        const userInfo = at === -1 ? "" : authority.slice(0, at);
+        const hostPart = at === -1 ? authority : authority.slice(at + 1);
+        const colon = userInfo.indexOf(":");
+        const user = this.decode(colon === -1 ? userInfo : userInfo.slice(0, colon), "the user name");
+        const password = colon === -1 ? "" : this.decode(userInfo.slice(colon + 1), "the password");
+        const hosts = this.parseHosts(hostPart, engine, scheme);
+        const database = this.parseDatabase(path, engine);
+        const { options, secretOptions } = this.parseQuery(query);
+        return {
+            engine: engine.engine,
+            scheme: scheme.name,
+            hosts,
+            user,
+            password,
+            database,
+            options,
+            secretOptions,
+        };
+    }
+    parseHosts(hostPart, engine, scheme) {
+        if (!hostPart) {
+            throw new InvalidConnectionUrlError("the host is missing.");
+        }
+        const hosts = hostPart.split(",").map((entry) => this.parseHost(entry, scheme));
+        if (hosts.length > 1 && !engine.multipleHosts) {
+            throw new InvalidConnectionUrlError(`${engine.label} URLs take a single host.`);
+        }
+        // An SRV record supplies the hosts and ports itself; a port in the URL is
+        // rejected by every MongoDB driver, so it is rejected here with a clearer
+        // message instead.
+        if (scheme.defaultPort === 0 && hosts.some((entry) => entry.port !== 0)) {
+            throw new InvalidConnectionUrlError(`${scheme.name} URLs must not include a port.`);
+        }
+        if (scheme.name === "mongodb+srv" && hosts.length > 1) {
+            throw new InvalidConnectionUrlError("mongodb+srv URLs take a single host name.");
+        }
+        return hosts;
+    }
+    /** Accepts `host`, `host:port`, `[::1]` and `[::1]:port`. */
+    parseHost(entry, scheme) {
+        let host;
+        let portText;
+        if (entry.startsWith("[")) {
+            const close = entry.indexOf("]");
+            if (close === -1) {
+                throw new InvalidConnectionUrlError("an IPv6 host is missing its closing bracket.");
+            }
+            host = entry.slice(1, close);
+            const after = entry.slice(close + 1);
+            portText = after.startsWith(":") ? after.slice(1) : undefined;
+        }
+        else {
+            const colon = entry.lastIndexOf(":");
+            host = colon === -1 ? entry : entry.slice(0, colon);
+            portText = colon === -1 ? undefined : entry.slice(colon + 1);
+        }
+        if (!host) {
+            throw new InvalidConnectionUrlError("the host is missing.");
+        }
+        return { host, port: portText === undefined ? scheme.defaultPort : this.parsePort(portText) };
+    }
+    parsePort(text) {
+        const port = Number(text);
+        if (!/^\d+$/.test(text) || !Number.isInteger(port) || port < 1 || port > 65535) {
+            throw new InvalidConnectionUrlError("the port must be a number from 1 to 65535.");
+        }
+        return port;
+    }
+    parseDatabase(path, engine) {
+        const trimmed = path.replace(/^\/+/, "").replace(/\/+$/, "");
+        if (!trimmed) {
+            return engine.defaultDatabase;
+        }
+        if (!engine.switchesDatabases) {
+            throw new InvalidConnectionUrlError(`${engine.label} URLs do not take a database in the path.`);
+        }
+        return this.decode(trimmed, "the database name");
+    }
+    parseQuery(query) {
+        const options = {};
+        const secretOptions = {};
+        for (const [name, value] of new URLSearchParams(query)) {
+            if (ConnectionUrlParser.SECRET_OPTION.test(name)) {
+                secretOptions[name] = value;
+            }
+            else {
+                options[name] = value;
+            }
+        }
+        return { options, secretOptions };
+    }
+    decode(value, what) {
+        try {
+            return decodeURIComponent(value);
+        }
+        catch {
+            throw new InvalidConnectionUrlError(`${what} contains malformed percent-encoding.`);
+        }
+    }
+    firstIndexOf(value, needles) {
+        const positions = needles.map((needle) => value.indexOf(needle)).filter((index) => index !== -1);
+        return positions.length === 0 ? -1 : Math.min(...positions);
+    }
+}

package/dist/domain/ConnectionProfile.js

@@ -0,0 +1,39 @@
+import { EngineCatalog } from "./Engine.js";
+/**
+ * A named connection.
+ *
+ * Distinct from ConnectionTarget because a name and an origin are not part of
+ * a connection's identity: the same endpoint can be reachable as "staging" from
+ * configuration and as an ad-hoc alias in the same session.
+ */
+export class ConnectionProfile {
+    name;
+    target;
+    origin;
+    constructor(name, target, origin) {
+        this.name = name;
+        this.target = target;
+        this.origin = origin;
+        Object.freeze(this);
+    }
+    /** Created from the environment, so it returns after a restart. */
+    static fromEnvironment(name, target) {
+        return new ConnectionProfile(name, target, "env");
+    }
+    /** Opened at runtime by the connect tool, so it is lost on exit. */
+    static fromSession(name, target) {
+        return new ConnectionProfile(name, target, "session");
+    }
+    /**
+     * One line for `list_connections`. Never contains the password.
+     *
+     * Names the engine in words as well as through the scheme, because with
+     * eight engines behind one server "which kind of database is this" is the
+     * first thing a reader needs to know about each line.
+     */
+    describe(isActive) {
+        const marker = isActive ? "* " : "  ";
+        const label = EngineCatalog.label(this.target.engine);
+        return `${marker}${this.name} (${this.origin}, ${label}) -> ${this.target.describe()}`;
+    }
+}

package/dist/domain/ConnectionTarget.js

@@ -0,0 +1,139 @@
+/**
+ * An immutable value object describing one connection, on any engine.
+ *
+ * Immutability is the point. A plain object passed around has to be
+ * spread-copied on every assignment, and a single missed copy means mutating
+ * the active connection silently rewrites the stored profile it came from.
+ * Here there is no setter to forget: `withDatabase` returns a new instance and
+ * the original cannot change.
+ *
+ * Identity is defined by the value of every non-secret field, exposed through
+ * `key()`, so the driver cache can treat two equal targets as one connection.
+ */
+export class ConnectionTarget {
+    engine;
+    scheme;
+    hosts;
+    user;
+    password;
+    database;
+    options;
+    secretOptions;
+    constructor(props) {
+        this.engine = props.engine;
+        this.scheme = props.scheme;
+        this.hosts = Object.freeze(props.hosts.map((entry) => Object.freeze({ ...entry })));
+        this.user = props.user;
+        this.password = props.password;
+        this.database = props.database;
+        this.options = Object.freeze({ ...props.options });
+        this.secretOptions = Object.freeze({ ...props.secretOptions });
+        Object.freeze(this);
+    }
+    /** The first host, which is the only one for every engine but MongoDB. */
+    get host() {
+        return this.hosts[0]?.host ?? "";
+    }
+    get port() {
+        return this.hosts[0]?.port ?? 0;
+    }
+    /**
+     * Stable identity, and the driver cache key.
+     *
+     * The password and every secret option are excluded deliberately: they are
+     * not part of what makes two connections the same endpoint, and this string
+     * is shown to users and written to logs. Because identity and display are
+     * the same string by construction, they cannot drift apart.
+     *
+     * A field added to this class that distinguishes two otherwise identical
+     * connections must be added here too, or the second will silently reuse the
+     * first one's driver.
+     */
+    key() {
+        if (this.engine === "sqlite") {
+            return `sqlite:${this.database}`;
+        }
+        const user = this.user ? `${this.user}@` : "";
+        const hosts = this.hosts
+            .map((entry) => (entry.port > 0 ? `${entry.host}:${entry.port}` : entry.host))
+            .join(",");
+        return `${this.scheme}://${user}${hosts}/${this.database}${this.optionSuffix()}`;
+    }
+    /** Human-readable form. Same as the key, and safe to print. */
+    describe() {
+        return this.key();
+    }
+    /**
+     * Same endpoint and same credentials.
+     *
+     * `key()` alone is not enough for the driver cache: a reconnect with a
+     * corrected password has the same key, and reusing the cached driver would
+     * keep using the wrong password.
+     */
+    equals(other) {
+        return (this.key() === other.key() &&
+            this.password === other.password &&
+            ConnectionTarget.sameRecord(this.secretOptions, other.secretOptions));
+    }
+    /** A copy pointing at a different database. The receiver is untouched. */
+    withDatabase(database) {
+        return new ConnectionTarget({ ...this.toProps(), database });
+    }
+    /**
+     * A URL parameter by name, ignoring case.
+     *
+     * Case-insensitive because connection-string conventions disagree
+     * (`trustServerCertificate`, `sslmode`, `authSource`), and a lookup that
+     * silently misses `TrustServerCertificate` would quietly change behaviour.
+     */
+    option(name) {
+        return ConnectionTarget.lookup(this.options, name);
+    }
+    secretOption(name) {
+        return ConnectionTarget.lookup(this.secretOptions, name);
+    }
+    /** Reads a boolean URL parameter: true, 1 and yes are true. */
+    flag(name) {
+        const value = this.option(name);
+        if (value === undefined) {
+            return undefined;
+        }
+        return ["true", "1", "yes"].includes(value.toLowerCase());
+    }
+    toProps() {
+        return {
+            engine: this.engine,
+            scheme: this.scheme,
+            hosts: this.hosts,
+            user: this.user,
+            password: this.password,
+            database: this.database,
+            options: this.options,
+            secretOptions: this.secretOptions,
+        };
+    }
+    /** Sorted so the same options in a different order are the same target. */
+    optionSuffix() {
+        const entries = Object.entries(this.options).sort(([a], [b]) => a.localeCompare(b));
+        if (entries.length === 0) {
+            return "";
+        }
+        return `?${entries.map(([name, value]) => `${name}=${value}`).join("&")}`;
+    }
+    static lookup(record, name) {
+        const wanted = name.toLowerCase();
+        for (const [key, value] of Object.entries(record)) {
+            if (key.toLowerCase() === wanted) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    static sameRecord(left, right) {
+        const leftKeys = Object.keys(left);
+        if (leftKeys.length !== Object.keys(right).length) {
+            return false;
+        }
+        return leftKeys.every((key) => left[key] === right[key]);
+    }
+}

package/dist/domain/Engine.js

@@ -0,0 +1,159 @@
+/**
+ * Static facts about each engine, in one table.
+ *
+ * Kept as data rather than spread across the drivers, because the connection
+ * layer needs these answers (which scheme is which engine, can it switch
+ * databases) long before any driver exists, and must not load a driver module
+ * to get them.
+ */
+export class EngineCatalog {
+    static DESCRIPTORS = [
+        {
+            engine: "mysql",
+            label: "MySQL",
+            family: "sql",
+            schemes: [
+                { name: "mysql", defaultPort: 3306, secure: false },
+                { name: "mariadb", defaultPort: 3306, secure: false },
+            ],
+            switchesDatabases: true,
+            defaultDatabase: "",
+            objectNoun: "table",
+            multipleHosts: false,
+        },
+        {
+            engine: "postgres",
+            label: "PostgreSQL",
+            family: "sql",
+            schemes: [
+                { name: "postgres", defaultPort: 5432, secure: false },
+                { name: "postgresql", defaultPort: 5432, secure: false },
+            ],
+            switchesDatabases: true,
+            defaultDatabase: "",
+            objectNoun: "table",
+            multipleHosts: false,
+        },
+        {
+            engine: "sqlite",
+            label: "SQLite",
+            family: "sql",
+            schemes: [{ name: "sqlite", defaultPort: 0, secure: false }],
+            switchesDatabases: false,
+            defaultDatabase: "",
+            objectNoun: "table",
+            multipleHosts: false,
+        },
+        {
+            engine: "mssql",
+            label: "SQL Server",
+            family: "sql",
+            schemes: [
+                { name: "mssql", defaultPort: 1433, secure: false },
+                { name: "sqlserver", defaultPort: 1433, secure: false },
+            ],
+            switchesDatabases: true,
+            defaultDatabase: "",
+            objectNoun: "table",
+            multipleHosts: false,
+        },
+        {
+            engine: "clickhouse",
+            label: "ClickHouse",
+            family: "sql",
+            // The HTTP interface, which is what the official JavaScript client
+            // speaks. The native protocol port 9000 is not what these point at.
+            schemes: [
+                { name: "clickhouse", defaultPort: 8123, secure: false },
+                { name: "clickhouse+https", defaultPort: 8443, secure: true },
+            ],
+            switchesDatabases: true,
+            defaultDatabase: "default",
+            objectNoun: "table",
+            multipleHosts: false,
+        },
+        {
+            engine: "mongodb",
+            label: "MongoDB",
+            family: "document",
+            schemes: [
+                { name: "mongodb", defaultPort: 27017, secure: false },
+                { name: "mongodb+srv", defaultPort: 0, secure: true },
+            ],
+            switchesDatabases: true,
+            defaultDatabase: "",
+            objectNoun: "collection",
+            multipleHosts: true,
+        },
+        {
+            engine: "redis",
+            label: "Redis",
+            family: "keyvalue",
+            schemes: [
+                { name: "redis", defaultPort: 6379, secure: false },
+                { name: "rediss", defaultPort: 6379, secure: true },
+            ],
+            switchesDatabases: true,
+            defaultDatabase: "0",
+            objectNoun: "key",
+            multipleHosts: false,
+        },
+        {
+            engine: "elasticsearch",
+            label: "Elasticsearch",
+            family: "search",
+            // OpenSearch answers the same read endpoints, so it shares the driver.
+            schemes: [
+                { name: "elasticsearch", defaultPort: 9200, secure: false },
+                { name: "elasticsearch+https", defaultPort: 9200, secure: true },
+                { name: "opensearch", defaultPort: 9200, secure: false },
+                { name: "opensearch+https", defaultPort: 9200, secure: true },
+            ],
+            switchesDatabases: false,
+            defaultDatabase: "",
+            objectNoun: "index",
+            multipleHosts: false,
+        },
+    ];
+    static all() {
+        return EngineCatalog.DESCRIPTORS;
+    }
+    static describe(engine) {
+        const descriptor = EngineCatalog.DESCRIPTORS.find((entry) => entry.engine === engine);
+        if (!descriptor) {
+            throw new Error(`Unknown engine "${engine}".`);
+        }
+        return descriptor;
+    }
+    static label(engine) {
+        return EngineCatalog.describe(engine).label;
+    }
+    /** @returns undefined for a scheme no engine claims. Case-insensitive. */
+    static findScheme(scheme) {
+        const wanted = scheme.toLowerCase();
+        for (const engine of EngineCatalog.DESCRIPTORS) {
+            const match = engine.schemes.find((entry) => entry.name === wanted);
+            if (match) {
+                return { engine, scheme: match };
+            }
+        }
+        return undefined;
+    }
+    /** @throws when the scheme is unknown, which a parsed target never has. */
+    static scheme(scheme) {
+        const found = EngineCatalog.findScheme(scheme);
+        if (!found) {
+            throw new Error(`Unknown scheme "${scheme}".`);
+        }
+        return found.scheme;
+    }
+    static schemeNames() {
+        return EngineCatalog.DESCRIPTORS.flatMap((engine) => engine.schemes.map((entry) => entry.name));
+    }
+    /** "MySQL, PostgreSQL, SQLite" for the engines of one family, for messages. */
+    static labelsFor(family) {
+        return EngineCatalog.DESCRIPTORS.filter((engine) => engine.family === family)
+            .map((engine) => engine.label)
+            .join(", ");
+    }
+}

package/dist/drivers/BaseDriver.js

@@ -0,0 +1,35 @@
+import { EngineCatalog } from "../domain/Engine.js";
+import { NoDatabaseSelectedError } from "../errors/NoDatabaseSelectedError.js";
+import { UnsupportedOperationError } from "../errors/UnsupportedOperationError.js";
+/**
+ * Shared behaviour for every driver.
+ *
+ * The two optional capabilities, indexes and foreign keys, default to a
+ * refusal here, so an engine without them needs no code to say so, and an
+ * engine that has them overrides the one method.
+ */
+export class BaseDriver {
+    target;
+    constructor(target) {
+        this.target = target;
+    }
+    async listIndexes(_name) {
+        throw new UnsupportedOperationError(this.label, "indexes to list");
+    }
+    async listForeignKeys(_name) {
+        throw new UnsupportedOperationError(this.label, "foreign keys");
+    }
+    get label() {
+        return EngineCatalog.label(this.target.engine);
+    }
+    get objectNoun() {
+        return EngineCatalog.describe(this.target.engine).objectNoun;
+    }
+    /** @throws NoDatabaseSelectedError explaining how to choose one. */
+    requireDatabase() {
+        if (!this.target.database) {
+            throw new NoDatabaseSelectedError(this.label);
+        }
+        return this.target.database;
+    }
+}

package/dist/drivers/DatabaseDriver.js

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

package/dist/drivers/DriverCache.js

@@ -0,0 +1,107 @@
+/**
+ * An Object Pool registry: one driver per distinct connection, with LRU
+ * eviction.
+ *
+ * This is what makes switching cheap. Changing database selects a different
+ * driver rather than reconnecting, and switching back reuses a warm one.
+ *
+ * Drivers are keyed by ConnectionTarget.key() rather than by, say, issuing
+ * `USE` on a shared pool. A pool holds several connections and `USE` affects
+ * only the one it ran on, so a later query served by a different connection
+ * would silently run against the old database. Keying by target means every
+ * connection a driver opens was pointed at the right database from the start.
+ */
+export class DriverCache {
+    registry;
+    maxDrivers;
+    drivers = new Map();
+    constructor(registry, maxDrivers) {
+        this.registry = registry;
+        this.maxDrivers = maxDrivers;
+    }
+    /**
+     * The cached driver for this target, or a new one.
+     *
+     * A cached driver whose target has the same key but different credentials
+     * is replaced, not reused. The key excludes the password by design, so
+     * without this check a reconnect with a corrected password would keep
+     * failing on the old one.
+     */
+    async acquire(target) {
+        const key = target.key();
+        const existing = this.drivers.get(key);
+        if (existing && existing.target.equals(target)) {
+            this.touch(key, existing);
+            return existing;
+        }
+        if (existing) {
+            this.drivers.delete(key);
+            await existing.close();
+        }
+        const driver = this.registry.create(target);
+        this.drivers.set(key, driver);
+        await this.evictOverflow();
+        return driver;
+    }
+    /**
+     * Open the connection and prove it works.
+     *
+     * A driver that fails verification is evicted, so the next attempt, perhaps
+     * after the server has come back, starts from nothing.
+     */
+    async verify(target) {
+        const driver = await this.acquire(target);
+        try {
+            await driver.verify();
+        }
+        catch (error) {
+            if (this.drivers.get(target.key()) === driver) {
+                this.drivers.delete(target.key());
+            }
+            await driver.close();
+            throw error;
+        }
+    }
+    /**
+     * Closing drivers is what allows the process to exit: open sockets keep the
+     * Node event loop alive.
+     *
+     * The map is cleared before awaiting, so a call arriving mid-shutdown gets a
+     * fresh driver rather than one being torn down. Closes run concurrently,
+     * because shutdown must not stall on one unreachable server.
+     */
+    async closeAll() {
+        const open = Array.from(this.drivers.values());
+        this.drivers.clear();
+        await Promise.all(open.map((driver) => driver.close()));
+    }
+    get size() {
+        return this.drivers.size;
+    }
+    /**
+     * A Map iterates in insertion order, so deleting and re-inserting moves an
+     * entry to the back and leaves the least recently used at the front. That is
+     * a complete LRU for two Map operations and no extra bookkeeping.
+     */
+    touch(key, driver) {
+        this.drivers.delete(key);
+        this.drivers.set(key, driver);
+    }
+    /**
+     * Runs after insertion, so the cap is briefly exceeded then corrected.
+     * Evicting first would risk dropping the driver that is about to be used.
+     */
+    async evictOverflow() {
+        while (this.drivers.size > this.maxDrivers) {
+            const oldest = this.drivers.keys().next();
+            if (oldest.done) {
+                return;
+            }
+            const driver = this.drivers.get(oldest.value);
+            this.drivers.delete(oldest.value);
+            if (driver) {
+                await driver.close();
+            }
+        }
+    }
+}