@shibbirweb/mcp-db-read-only 0.1.0

package/dist/drivers/sql/SqliteWorker.js

@@ -0,0 +1,71 @@
+import { DatabaseSync } from "node:sqlite";
+/**
+ * Owns one read-only SQLite database, in a child process.
+ *
+ * node:sqlite is synchronous: a query runs on the calling thread until it
+ * finishes, and there is no way to interrupt it from JavaScript. On the main
+ * thread, one runaway query would freeze the whole MCP server.
+ *
+ * A child process rather than a worker thread, which was tried first and
+ * failed: `worker.terminate()` stops JavaScript, but a thread inside
+ * SQLite's native `sqlite3_step` never returns to JavaScript, so the
+ * terminate waited forever and took the server with it. A process can always
+ * be killed, whatever it is doing.
+ *
+ * The database is opened read-only at the file level, which is SQLite's own
+ * guarantee and the second layer behind the SQL validator. `query_only` is set
+ * as well, though it can be switched off from SQL and so is not relied on.
+ *
+ * stdout is never written: the parent does not even connect it, because the
+ * parent's own stdout is the JSON-RPC stream.
+ */
+function send(message) {
+    process.send?.(message);
+}
+function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Integers arrive as bigint so none is rounded on the way out. Those that fit
+ * a double exactly go back to plain numbers here, which is nearly all of them.
+ */
+function normalise(row) {
+    const out = {};
+    for (const [column, value] of Object.entries(row)) {
+        out[column] =
+            typeof value === "bigint" && Number.isSafeInteger(Number(value)) ? Number(value) : value;
+    }
+    return out;
+}
+// The parent going away closes the IPC channel. Exiting then means a killed
+// or crashed server never leaves an orphan holding the database file open.
+process.on("disconnect", () => process.exit(0));
+const options = JSON.parse(process.argv[2] ?? "{}");
+let database;
+try {
+    database = new DatabaseSync(options.path, {
+        readOnly: true,
+        // Extensions are native code; loading one is the classic route out of
+        // SQLite's sandbox.
+        allowExtension: false,
+        timeout: options.busyTimeoutMs,
+        readBigInts: true,
+    });
+    database.exec("PRAGMA query_only = ON");
+    send({ type: "ready" });
+}
+catch (error) {
+    send({ type: "failed", error: describe(error) });
+    process.exit(0);
+}
+process.on("message", (request) => {
+    let response;
+    try {
+        const rows = database.prepare(request.sql).all(...request.params);
+        response = { id: request.id, rows: rows.map(normalise) };
+    }
+    catch (error) {
+        response = { id: request.id, error: describe(error) };
+    }
+    send(response);
+});

package/dist/errors/ApplicationError.js

@@ -0,0 +1,15 @@
+/**
+ * Base for errors this server raises deliberately.
+ *
+ * Tool handlers turn any thrown error into a tool result, so the distinction
+ * that matters is not the class but the message: it is read by a person or a
+ * model deciding what to do next. Every subclass therefore writes a message
+ * that names the fix, not just the fault.
+ */
+export class ApplicationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = new.target.name;
+        Error.captureStackTrace?.(this, new.target);
+    }
+}

package/dist/errors/EngineMismatchError.js

@@ -0,0 +1,15 @@
+import { ApplicationError } from "./ApplicationError.js";
+/**
+ * Raised when a query tool is called against an engine it does not speak.
+ *
+ * Every tool is advertised all the time, because MCP fixes the tool list at
+ * handshake while the active engine changes mid-conversation. So `run_query`
+ * can be called against MongoDB, and when it is, the most useful answer names
+ * the tools that do work there.
+ */
+export class EngineMismatchError extends ApplicationError {
+    constructor(toolName, supportedEngines, activeEngine, alternatives) {
+        const instead = alternatives.length > 0 ? ` Use ${alternatives.join(", ")} for ${activeEngine}.` : "";
+        super(`${toolName} works on ${supportedEngines} connections, but the active connection is ${activeEngine}.${instead}`);
+    }
+}

package/dist/errors/InvalidConnectionUrlError.js

@@ -0,0 +1,14 @@
+import { ApplicationError } from "./ApplicationError.js";
+/**
+ * Raised when a connection URL cannot be understood.
+ *
+ * The message never contains the URL itself. A URL is where the password
+ * usually lives, and this message is shown to the user, logged to stderr, and
+ * handed to the model. Callers describe the problem ("port is not a number")
+ * without echoing the input that caused it.
+ */
+export class InvalidConnectionUrlError extends ApplicationError {
+    constructor(reason) {
+        super(`Invalid connection URL: ${reason}`);
+    }
+}

package/dist/errors/InvalidProfileDefinitionError.js

@@ -0,0 +1,15 @@
+import { ApplicationError } from "./ApplicationError.js";
+/**
+ * Raised while parsing one entry of DB_PROFILES or MYSQL_PROFILES.
+ *
+ * Caught by the configuration loader and turned into a warning: one malformed
+ * profile must not stop the server starting, because a running server can be
+ * repaired with the connect tool while a dead one cannot be diagnosed at all.
+ */
+export class InvalidProfileDefinitionError extends ApplicationError {
+    profileName;
+    constructor(profileName, reason) {
+        super(`Profile "${profileName}" ${reason}`);
+        this.profileName = profileName;
+    }
+}

package/dist/errors/NoActiveConnectionError.js

@@ -0,0 +1,13 @@
+import { ApplicationError } from "./ApplicationError.js";
+/**
+ * Raised when a read is attempted before any connection has been chosen.
+ *
+ * Reaching this is normal rather than exceptional: the server starts happily
+ * with no configuration, so the message has to double as the instructions for
+ * getting out of that state.
+ */
+export class NoActiveConnectionError extends ApplicationError {
+    constructor() {
+        super("No active connection. Call connect with a connection URL, or use_connection with a profile name.");
+    }
+}

package/dist/errors/NoDatabaseSelectedError.js

@@ -0,0 +1,13 @@
+import { ApplicationError } from "./ApplicationError.js";
+/**
+ * Raised when a connection URL named no database and the operation needs one.
+ *
+ * A URL without a database is legitimate, and common for MongoDB and SQL
+ * Server, so it is accepted at connect time. The error is deferred to the
+ * first operation that genuinely needs a database, and says how to pick one.
+ */
+export class NoDatabaseSelectedError extends ApplicationError {
+    constructor(engineLabel) {
+        super(`No database selected on this ${engineLabel} connection. Call list_databases, then use_database, or pass the database argument.`);
+    }
+}

package/dist/errors/ObjectNotFoundError.js

@@ -0,0 +1,14 @@
+import { ApplicationError } from "./ApplicationError.js";
+/**
+ * Raised when a table, collection, key or index does not exist.
+ *
+ * Several engines answer a question about a missing table with an empty
+ * result rather than an error, and an empty result reads as "it has no
+ * columns". Saying plainly that it does not exist, and how to see what does,
+ * gets the caller unstuck in one step.
+ */
+export class ObjectNotFoundError extends ApplicationError {
+    constructor(noun, name) {
+        super(`No ${noun} named "${name}" was found. Call list_tables to see what exists.`);
+    }
+}

package/dist/errors/UnknownProfileError.js

@@ -0,0 +1,16 @@
+import { ApplicationError } from "./ApplicationError.js";
+/**
+ * Raised when a profile name does not exist.
+ *
+ * Carries the known names, because a mistyped profile is almost always fixed
+ * by seeing the real list rather than by being told the name was wrong.
+ */
+export class UnknownProfileError extends ApplicationError {
+    profileName;
+    knownProfiles;
+    constructor(profileName, knownProfiles) {
+        super(`Unknown profile "${profileName}". Known profiles: ${knownProfiles.join(", ") || "none"}`);
+        this.profileName = profileName;
+        this.knownProfiles = knownProfiles;
+    }
+}

package/dist/errors/UnsupportedOperationError.js

@@ -0,0 +1,14 @@
+import { ApplicationError } from "./ApplicationError.js";
+/**
+ * Raised when the active engine has no equivalent of what was asked.
+ *
+ * Redis has no foreign keys and Elasticsearch has no databases. These are not
+ * failures of the server, so the message says what the engine does have
+ * instead, which is usually what the caller wanted in the first place.
+ */
+export class UnsupportedOperationError extends ApplicationError {
+    constructor(engineLabel, operation, alternative) {
+        const suffix = alternative ? ` ${alternative}` : "";
+        super(`${engineLabel} has no ${operation}.${suffix}`);
+    }
+}

package/dist/errors/index.js

@@ -0,0 +1,9 @@
+export { ApplicationError } from "./ApplicationError.js";
+export { NoActiveConnectionError } from "./NoActiveConnectionError.js";
+export { NoDatabaseSelectedError } from "./NoDatabaseSelectedError.js";
+export { UnknownProfileError } from "./UnknownProfileError.js";
+export { InvalidProfileDefinitionError } from "./InvalidProfileDefinitionError.js";
+export { InvalidConnectionUrlError } from "./InvalidConnectionUrlError.js";
+export { UnsupportedOperationError } from "./UnsupportedOperationError.js";
+export { EngineMismatchError } from "./EngineMismatchError.js";
+export { ObjectNotFoundError } from "./ObjectNotFoundError.js";

package/dist/formatting/JsonSerializer.js

@@ -0,0 +1,49 @@
+/**
+ * Turns driver output into JSON a person and a model can read.
+ *
+ * Plain `JSON.stringify` fails in three ways across these drivers:
+ *
+ * - It throws on a `bigint`, which SQLite, ClickHouse and MongoDB can return.
+ * - It renders a Buffer as `{"type":"Buffer","data":[1,2,3,...]}`, one number
+ *   per byte, which floods the context window with a binary column.
+ * - It renders a Map (Redis replies, some driver metadata) as `{}`.
+ *
+ * A single serializer used by every tool means a new driver cannot forget one
+ * of these.
+ */
+export class JsonSerializer {
+    /** Enough bytes to recognise a value; the length says how much was omitted. */
+    static BINARY_PREVIEW_BYTES = 32;
+    stringify(value) {
+        const serializer = this;
+        return JSON.stringify(value, 
+        // A function rather than an arrow, because the replacer receives the
+        // value after toJSON has already run, and only `this[key]` still holds
+        // the original Buffer.
+        function (key, replaced) {
+            return serializer.replace(this[key], replaced);
+        }, 2) ?? "null";
+    }
+    replace(original, replaced) {
+        if (typeof original === "bigint") {
+            // Exact where a number can be, a string where it cannot, so no digit
+            // is ever silently rounded away.
+            return Number.isSafeInteger(Number(original)) ? Number(original) : original.toString();
+        }
+        if (original instanceof Uint8Array) {
+            return this.describeBinary(original);
+        }
+        if (original instanceof Map) {
+            return Object.fromEntries(original);
+        }
+        if (original instanceof Set) {
+            return Array.from(original);
+        }
+        return replaced;
+    }
+    describeBinary(bytes) {
+        const shown = Buffer.from(bytes.subarray(0, JsonSerializer.BINARY_PREVIEW_BYTES)).toString("hex");
+        const more = bytes.length > JsonSerializer.BINARY_PREVIEW_BYTES ? "..." : "";
+        return `<binary ${bytes.length} bytes: 0x${shown}${more}>`;
+    }
+}

package/dist/formatting/RowFormatter.js

@@ -0,0 +1,43 @@
+import { JsonSerializer } from "./JsonSerializer.js";
+/**
+ * Renders query results for a conversation.
+ *
+ * Truncation protects the context window: `SELECT *` on a large table would
+ * otherwise flood the transcript and can exceed the client's message limit
+ * outright.
+ *
+ * This truncates *output*. Bounding the work the database does is the job of
+ * each driver's server-side timeout.
+ */
+export class RowFormatter {
+    maxRows;
+    serializer;
+    static DEFAULT_MAX_ROWS = 100;
+    constructor(maxRows = RowFormatter.DEFAULT_MAX_ROWS, serializer = new JsonSerializer()) {
+        this.maxRows = maxRows;
+        this.serializer = serializer;
+    }
+    /**
+     * @param narrowing how to ask for fewer rows on this engine ("Add a LIMIT
+     *   clause"), so the note names the fix in the caller's own terms.
+     * @param moreBeyond set when a driver already stopped reading at the cap,
+     *   so the true total is unknown but known to be larger.
+     */
+    format(rows, narrowing, moreBeyond = false) {
+        const truncated = rows.length > this.maxRows;
+        const shown = truncated ? rows.slice(0, this.maxRows) : rows;
+        const body = this.serializer.stringify(shown);
+        if (truncated) {
+            // The note states the true total, so the reader knows they are seeing
+            // a sample and how large the whole is.
+            return `${body}\n\n--- Showing ${this.maxRows} of ${rows.length} rows. ${narrowing} for smaller results. ---`;
+        }
+        if (moreBeyond) {
+            return `${body}\n\n--- Showing the first ${shown.length} results; there are more. ${narrowing} for smaller results. ---`;
+        }
+        return body;
+    }
+    get limit() {
+        return this.maxRows;
+    }
+}

package/dist/formatting/ToolResponse.js

@@ -0,0 +1,25 @@
+import { JsonSerializer } from "./JsonSerializer.js";
+/**
+ * Builds MCP tool results.
+ *
+ * Static factories rather than an instance, because there is no state and
+ * every tool needs them. Having one place that constructs the content envelope
+ * means `isError` is set consistently and no handler hand-rolls the shape.
+ */
+export class ToolResponse {
+    static serializer = new JsonSerializer();
+    static text(body) {
+        return { content: [{ type: "text", text: body }] };
+    }
+    static json(value) {
+        return ToolResponse.text(ToolResponse.serializer.stringify(value));
+    }
+    /**
+     * The `Error: ` prefix is load-bearing. An assistant reads tool output to
+     * decide what to do next, and an unprefixed message is easily mistaken for
+     * data rather than a failure.
+     */
+    static failure(body) {
+        return { content: [{ type: "text", text: `Error: ${body}` }], isError: true };
+    }
+}

package/dist/index.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { ApplicationFactory } from "./ApplicationFactory.js";
+/**
+ * Entry point. Nothing but construction and start.
+ *
+ * There is no configuration check and no exit path here on purpose. A server
+ * with no usable connection still starts, still answers tools/list, and
+ * reports the problem through tool results. An MCP client cannot show a stderr
+ * message from a process that exited during handshake; it reports "server
+ * failed to start", which is indistinguishable from a broken image or a wrong
+ * path. A running server that says "call connect" is diagnosable, and usually
+ * fixable in the same conversation.
+ */
+const application = new ApplicationFactory();
+await application.create().start();

package/dist/server/McpDbServer.js

@@ -0,0 +1,69 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+/**
+ * Owns the MCP server's lifetime.
+ *
+ * Takes tools as an already-constructed list rather than building them, so
+ * this class knows nothing about databases or about which tools exist. Wiring
+ * is the composition root's job; running is this one's.
+ */
+export class McpDbServer {
+    tools;
+    drivers;
+    logger;
+    server;
+    shuttingDown = false;
+    /**
+     * `version` is required and has no default on purpose: a default here is a
+     * second place to remember at release time, and the one that silently wins
+     * when it is forgotten. The composition root reads it from `package.json`.
+     */
+    constructor(tools, drivers, logger, version, name = "db-readonly-switchable") {
+        this.tools = tools;
+        this.drivers = drivers;
+        this.logger = logger;
+        this.server = new McpServer({ name, version });
+    }
+    async start() {
+        // Registered before the transport connects, so a tools/list arriving
+        // immediately after the handshake can be answered.
+        for (const tool of this.tools) {
+            tool.register(this.server);
+        }
+        this.installSignalHandlers();
+        await this.server.connect(new StdioServerTransport());
+        // stderr, always. On stdio transport stdout carries JSON-RPC and a single
+        // stray byte corrupts the stream.
+        this.logger("MCP database server running (read-only, switchable connection)");
+    }
+    /**
+     * Only signals, deliberately.
+     *
+     * Once a query has run a driver holds open sockets, and open handles keep
+     * the Node event loop alive, so the process cannot exit on its own. That
+     * makes it tempting to shut down when stdin closes. It is a trap, found the
+     * hard way in the MySQL-only predecessor: stdin `end` fires when no further
+     * requests are *buffered*, not when the client has gone. A client that
+     * writes several requests and waits reaches EOF while they are still being
+     * processed, so connections were torn down mid-flight and every later call
+     * failed.
+     *
+     * SIGTERM is what a client sends when it is genuinely finished.
+     */
+    installSignalHandlers() {
+        const shutdown = () => {
+            void this.shutdown();
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+    }
+    /** Idempotent, so a repeated signal cannot tear down drivers twice at once. */
+    async shutdown() {
+        if (this.shuttingDown) {
+            return;
+        }
+        this.shuttingDown = true;
+        await this.drivers.closeAll();
+        process.exit(0);
+    }
+}

package/dist/tools/BaseTool.js

@@ -0,0 +1,42 @@
+import { ToolResponse } from "../formatting/ToolResponse.js";
+/**
+ * Template Method base for every tool.
+ *
+ * `register` and `invoke` are fixed; subclasses supply only `execute`. That
+ * makes the error contract impossible to forget, which matters because an MCP
+ * server that throws out of a handler can take the client's whole session with
+ * it.
+ */
+export class BaseTool {
+    /**
+     * The cast is confined to this one line: the SDK derives the callback's
+     * argument type from the schema it was given, which it cannot do for a
+     * schema held in an abstract property. Every subclass declares its own
+     * argument interface, so the type is recovered immediately below.
+     */
+    register(server) {
+        server.registerTool(this.name, {
+            // Sent at the top level as well as inside the annotations: newer
+            // clients read the top-level field, older ones only the annotation.
+            title: this.annotations.title,
+            description: this.description,
+            inputSchema: this.inputSchema,
+            annotations: this.annotations,
+        }, (args) => this.invoke(args));
+    }
+    /**
+     * The one place a thrown error becomes a tool error.
+     *
+     * A dropped connection, a syntax error or an unconfigured server all
+     * arrive here and leave as readable text, so the process stays alive and the
+     * user can simply try again.
+     */
+    async invoke(args) {
+        try {
+            return await this.execute(args);
+        }
+        catch (error) {
+            return ToolResponse.failure(error instanceof Error ? error.message : String(error));
+        }
+    }
+}

package/dist/tools/DatabaseScopedTool.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import { BaseTool } from "./BaseTool.js";
+import { ToolResponse } from "../formatting/ToolResponse.js";
+/**
+ * Base for every tool that reads through the active connection.
+ *
+ * Refines the Template Method one step further: `execute` is implemented here
+ * to resolve the connection, check the tool fits its engine, and validate the
+ * shared `database` argument, and subclasses supply `read`. Without this,
+ * every tool would repeat the same three guards, and a new tool could
+ * silently omit one and interpolate an unchecked name.
+ *
+ * The per-call `database` override exists for two reasons: comparing two
+ * databases otherwise means switching, reading and switching back, and a call
+ * carrying its own database does not depend on shared mutable state, so it
+ * cannot be reordered against a switch issued in the same batch.
+ */
+export class DatabaseScopedTool extends BaseTool {
+    drivers;
+    names;
+    /** Reused by every subclass so the argument reads identically everywhere. */
+    static databaseParam = z
+        .string()
+        .optional()
+        .describe("Optional database to read from for this call only, without changing the active connection");
+    /**
+     * The engine family this tool speaks, or null for the browse tools that
+     * work on every engine. Checked before anything else, so run_query against
+     * MongoDB fails with a pointer to the right tool rather than a parse error.
+     */
+    family = null;
+    constructor(drivers, names) {
+        super();
+        this.drivers = drivers;
+        this.names = names;
+    }
+    async execute(args) {
+        const active = this.drivers.requireActiveTarget();
+        if (this.family) {
+            this.drivers.requireFamily(active, this.family, this.name);
+        }
+        if (args.database) {
+            const rejection = this.reject(this.names.for(active.engine).validateDatabase(args.database));
+            if (rejection) {
+                return rejection;
+            }
+        }
+        return this.read(args, this.drivers.resolveTarget(args.database));
+    }
+    /**
+     * @returns a failure result, or null when the name is valid. Returning a
+     *   value rather than throwing keeps "the caller passed something invalid"
+     *   distinct from "something failed at runtime".
+     */
+    validateObjectName(target, value, label) {
+        return this.reject(this.names.for(target.engine).validateObject(value, label));
+    }
+    reject(result) {
+        return result.valid ? null : ToolResponse.failure(result.error ?? "Invalid argument.");
+    }
+}

package/dist/tools/QueryTools.js

@@ -0,0 +1,13 @@
+/**
+ * The query tools for each engine family.
+ *
+ * Lives beside the tools rather than in the engine catalog, because the
+ * domain layer should not know tool names. DriverProvider receives it so that
+ * calling a query tool against the wrong engine names the right ones.
+ */
+export const QUERY_TOOLS = {
+    sql: ["run_query"],
+    document: ["find_documents", "aggregate", "count_documents", "distinct_values"],
+    keyvalue: ["redis_command"],
+    search: ["search"],
+};

package/dist/tools/browse/DescribeTableTool.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { DatabaseScopedTool } from "../DatabaseScopedTool.js";
+import { ToolResponse } from "../../formatting/ToolResponse.js";
+/**
+ * The shape of one table, in each engine's terms.
+ *
+ * Columns on SQL engines, fields inferred from sampled documents on MongoDB,
+ * the mapping on Elasticsearch, and type, TTL and size for a Redis key.
+ */
+export class DescribeTableTool extends DatabaseScopedTool {
+    name = "describe_table";
+    description = "Show the structure of a table: columns on SQL engines, inferred fields for a MongoDB collection, the mapping of an Elasticsearch index, or the type and TTL of a Redis key";
+    annotations = {
+        title: "Describe Table",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    };
+    inputSchema = {
+        table: z
+            .string()
+            .describe("Table name (schema.table where the engine has schemas), collection, Redis key, or index"),
+        database: DatabaseScopedTool.databaseParam,
+    };
+    constructor(drivers, names) {
+        super(drivers, names);
+    }
+    async read(args, target) {
+        const rejection = this.validateObjectName(target, args.table, "table name");
+        if (rejection) {
+            return rejection;
+        }
+        const driver = await this.drivers.acquire(target);
+        return ToolResponse.json(await driver.describeObject(args.table));
+    }
+}

package/dist/tools/browse/GetForeignKeysTool.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { DatabaseScopedTool } from "../DatabaseScopedTool.js";
+import { ToolResponse } from "../../formatting/ToolResponse.js";
+/** Foreign keys declared on one table, on the relational engines that have them. */
+export class GetForeignKeysTool extends DatabaseScopedTool {
+    name = "get_foreign_keys";
+    description = "Show foreign key relationships for a table on MySQL, PostgreSQL, SQLite or SQL Server";
+    annotations = {
+        title: "Get Foreign Keys",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    };
+    inputSchema = {
+        table: z.string().describe("Table name"),
+        database: DatabaseScopedTool.databaseParam,
+    };
+    constructor(drivers, names) {
+        super(drivers, names);
+    }
+    async read(args, target) {
+        const rejection = this.validateObjectName(target, args.table, "table name");
+        if (rejection) {
+            return rejection;
+        }
+        const driver = await this.drivers.acquire(target);
+        const rows = await driver.listForeignKeys(args.table);
+        // A sentence rather than []: an empty array reads as "the query failed",
+        // a sentence reads as an answer.
+        if (rows.length === 0) {
+            return ToolResponse.text(`No foreign keys found for table "${args.table}".`);
+        }
+        return ToolResponse.json(rows);
+    }
+}

package/dist/tools/browse/GetTableIndexesTool.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { DatabaseScopedTool } from "../DatabaseScopedTool.js";
+import { ToolResponse } from "../../formatting/ToolResponse.js";
+/** Indexes on one table or collection. */
+export class GetTableIndexesTool extends DatabaseScopedTool {
+    name = "get_table_indexes";
+    description = "Show indexes on a table or MongoDB collection, or the sorting key and skipping indices of a ClickHouse table";
+    annotations = {
+        title: "Get Table Indexes",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    };
+    inputSchema = {
+        table: z.string().describe("Table or collection name"),
+        database: DatabaseScopedTool.databaseParam,
+    };
+    constructor(drivers, names) {
+        super(drivers, names);
+    }
+    async read(args, target) {
+        const rejection = this.validateObjectName(target, args.table, "table name");
+        if (rejection) {
+            return rejection;
+        }
+        const driver = await this.drivers.acquire(target);
+        return ToolResponse.json(await driver.listIndexes(args.table));
+    }
+}