@shibbirweb/mcp-db-read-only 0.1.0

package/dist/tools/browse/GetTableSampleTool.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { DatabaseScopedTool } from "../DatabaseScopedTool.js";
+import { ToolResponse } from "../../formatting/ToolResponse.js";
+/** A handful of real rows, documents, hits, or the start of a Redis value. */
+export class GetTableSampleTool extends DatabaseScopedTool {
+    name = "get_table_sample";
+    description = "Get sample rows from a table, documents from a collection, hits from an index, or the first entries of a Redis key";
+    static MIN_LIMIT = 1;
+    static MAX_LIMIT = 50;
+    annotations = {
+        title: "Get Table Sample",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    };
+    inputSchema = {
+        table: z.string().describe("Table, collection, index, or Redis key"),
+        limit: z
+            .number()
+            .min(GetTableSampleTool.MIN_LIMIT)
+            .max(GetTableSampleTool.MAX_LIMIT)
+            .default(5)
+            .describe("Number of rows to return (1-50, default 5)"),
+        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.sample(args.table, this.clampLimit(args.limit)));
+    }
+    /**
+     * Some drivers interpolate the limit, because not every engine accepts a
+     * placeholder in LIMIT.
+     *
+     * Clamping here duplicates the Zod constraint on purpose. The schema is
+     * enforced by the client before dispatch; clamping in the handler means a
+     * value reaching a query string cannot be anything but an integer in range,
+     * however it got here.
+     */
+    clampLimit(limit) {
+        return Math.min(Math.max(Math.trunc(limit), GetTableSampleTool.MIN_LIMIT), GetTableSampleTool.MAX_LIMIT);
+    }
+}

package/dist/tools/browse/ListTablesTool.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { DatabaseScopedTool } from "../DatabaseScopedTool.js";
+import { EngineCatalog } from "../../domain/Engine.js";
+import { ToolResponse } from "../../formatting/ToolResponse.js";
+/** Lists tables, collections, keys or indices, whichever the engine has. */
+export class ListTablesTool extends DatabaseScopedTool {
+    name = "list_tables";
+    description = "List the tables in the active database: collections on MongoDB, keys on Redis, indices on Elasticsearch";
+    /**
+     * Enough to see what is there on any real schema. The cap matters most on
+     * Redis, where "tables" are keys and a production instance holds millions.
+     */
+    static MAX_NAMES = 1000;
+    annotations = {
+        title: "List Tables",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    };
+    inputSchema = {
+        pattern: z
+            .string()
+            .optional()
+            .describe("Optional glob filter, * for any characters and ? for one, e.g. user* or logs-2026-*"),
+        database: DatabaseScopedTool.databaseParam,
+    };
+    constructor(drivers, names) {
+        super(drivers, names);
+    }
+    async read(args, target) {
+        if (args.pattern) {
+            const rejection = this.reject(this.names.for(target.engine).validatePattern(args.pattern));
+            if (rejection) {
+                return rejection;
+            }
+        }
+        const driver = await this.drivers.acquire(target);
+        const listing = await driver.listObjects(args.pattern, ListTablesTool.MAX_NAMES);
+        const noun = EngineCatalog.describe(target.engine).objectNoun;
+        const heading = `${this.plural(noun)} (${listing.names.length}${listing.truncated ? "+" : ""})`;
+        const note = listing.truncated
+            ? `\n\n--- Showing the first ${listing.names.length}. Pass a pattern to narrow the list. ---`
+            : "";
+        return ToolResponse.text(`${heading}:\n${listing.names.join("\n")}${note}`);
+    }
+    plural(noun) {
+        const capitalised = `${noun[0].toUpperCase()}${noun.slice(1)}`;
+        return noun === "index" ? "Indices" : `${capitalised}s`;
+    }
+}

package/dist/tools/connection/ConnectTool.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { BaseTool } from "../BaseTool.js";
+import { EngineCatalog } from "../../domain/Engine.js";
+import { ToolResponse } from "../../formatting/ToolResponse.js";
+/**
+ * Opens an arbitrary server, on any engine, at runtime.
+ *
+ * This is the tool that makes a restart unnecessary in every case.
+ * DB_PROFILES is a convenience; this is the guarantee.
+ */
+export class ConnectTool extends BaseTool {
+    connections;
+    targetFactory;
+    names;
+    name = "connect";
+    description = "Connect to a database at runtime with a connection URL (mysql, mariadb, postgres, sqlite, mssql, clickhouse, mongodb, redis, elasticsearch, opensearch). Not persisted to disk, but kept for the rest of the session under an alias";
+    /**
+     * Not read-only: it opens a server and stores the alias for the session.
+     * Not destructive either, because nothing in any database changes, and
+     * re-running the same call lands on the same connection.
+     */
+    annotations = {
+        title: "Connect to Database",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    };
+    /** Used when no alias is given, so repeated ad-hoc connections overwrite. */
+    static DEFAULT_ALIAS = "custom";
+    inputSchema = {
+        url: z
+            .string()
+            // The two most common setup mistakes, spelled out because a model
+            // reading this description usually gets them right unprompted:
+            // localhost inside a container, and a SQLite path without three slashes.
+            .describe("Connection URL, e.g. postgres://user@host:5432/db, mongodb://user@host/db, redis://host:6379/0, sqlite:///path/to/file.db. Use host.docker.internal for a database on this machine when running in Docker"),
+        password: z
+            .string()
+            .optional()
+            .describe("Password, if not in the URL. Avoids percent-encoding special characters"),
+        alias: z
+            .string()
+            .optional()
+            .describe("Name to remember this connection under for use_connection later"),
+    };
+    constructor(connections, targetFactory, names) {
+        super();
+        this.connections = connections;
+        this.targetFactory = targetFactory;
+        this.names = names;
+    }
+    async execute(args) {
+        const target = this.targetFactory.fromUrl(args.url, args.password);
+        // A SQLite target's database is its file path, which no name policy
+        // describes; everything else is checked like any other database name.
+        if (target.database && EngineCatalog.describe(target.engine).switchesDatabases) {
+            const check = this.names.for(target.engine).validateDatabase(target.database);
+            if (!check.valid) {
+                return ToolResponse.failure(check.error ?? "Invalid database name.");
+            }
+        }
+        const alias = args.alias ?? ConnectTool.DEFAULT_ALIAS;
+        await this.connections.connect(target, alias);
+        return ToolResponse.text(`Connected as "${alias}" (${EngineCatalog.label(target.engine)}) -> ${target.describe()}`);
+    }
+}

package/dist/tools/connection/CurrentConnectionTool.js

@@ -0,0 +1,36 @@
+import { BaseTool } from "../BaseTool.js";
+import { EngineCatalog } from "../../domain/Engine.js";
+import { ToolResponse } from "../../formatting/ToolResponse.js";
+/** Reports the active connection, its engine and its database. */
+export class CurrentConnectionTool extends BaseTool {
+    connections;
+    name = "current_connection";
+    description = "Show which database server, engine and database the read-only tools are currently pointed at";
+    annotations = {
+        title: "Show Current Connection",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    };
+    inputSchema = {};
+    constructor(connections) {
+        super();
+        this.connections = connections;
+    }
+    async execute() {
+        const target = this.connections.getActiveTarget();
+        // Reads the nullable accessor rather than the asserting one, so an
+        // unconfigured server reports its state as ordinary output instead of an
+        // error. Nothing has gone wrong; nothing has been chosen yet.
+        if (!target) {
+            return ToolResponse.text("No active connection. Call connect or use_connection to set one.");
+        }
+        // Rendering through describe() is what keeps the password out of output.
+        return ToolResponse.text([
+            `Active profile: ${this.connections.getActiveName()}`,
+            `Engine: ${EngineCatalog.label(target.engine)}`,
+            `Target: ${target.describe()}`,
+        ].join("\n"));
+    }
+}

package/dist/tools/connection/ListConnectionsTool.js

@@ -0,0 +1,38 @@
+import { BaseTool } from "../BaseTool.js";
+import { ToolResponse } from "../../formatting/ToolResponse.js";
+/**
+ * Lists the profiles available to switch to.
+ *
+ * Shows each profile's origin and engine: `(env)` versus `(session)` tells the
+ * reader whether the connection will still be there after a restart, and the
+ * engine says which query tools apply to it.
+ */
+export class ListConnectionsTool extends BaseTool {
+    connections;
+    name = "list_connections";
+    description = "List the connection profiles available to switch to, with each one's engine, including any added during this session";
+    annotations = {
+        title: "List Connection Profiles",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    };
+    inputSchema = {};
+    constructor(connections) {
+        super();
+        this.connections = connections;
+    }
+    async execute() {
+        const profiles = this.connections.listProfiles();
+        if (profiles.length === 0) {
+            return ToolResponse.text("No profiles configured. Use connect to open one directly.");
+        }
+        const activeName = this.connections.getActiveName();
+        // The profile renders its own line, including the "* " active marker, so
+        // the display rule lives with the entity rather than being duplicated by
+        // every caller that wants to show a profile.
+        const lines = profiles.map((profile) => profile.describe(profile.name === activeName));
+        return ToolResponse.text(`Connection profiles:\n${lines.join("\n")}`);
+    }
+}

package/dist/tools/connection/ListDatabasesTool.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { BaseTool } from "../BaseTool.js";
+import { ToolResponse } from "../../formatting/ToolResponse.js";
+/** Lists databases on the connected server, marking the active one. */
+export class ListDatabasesTool extends BaseTool {
+    drivers;
+    name = "list_databases";
+    description = "List databases on the currently connected server (schemas on MySQL, numbered databases on Redis)";
+    annotations = {
+        title: "List Databases",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    };
+    /**
+     * System databases are noise in almost every session and make it harder to
+     * spot the one you want. `include_system` exists because inspecting them is
+     * occasionally the real task.
+     */
+    inputSchema = {
+        include_system: z
+            .boolean()
+            .default(false)
+            .describe("Include system databases such as information_schema, pg templates, or MongoDB admin and local"),
+    };
+    constructor(drivers) {
+        super();
+        this.drivers = drivers;
+    }
+    async execute(args) {
+        const target = this.drivers.requireActiveTarget();
+        const driver = await this.drivers.acquire(target);
+        const entries = await driver.listDatabases();
+        const names = entries
+            .filter((entry) => args.include_system || !entry.system)
+            .map((entry) => entry.name);
+        const lines = names.map((name) => (name === target.database ? `* ${name}` : `  ${name}`));
+        return ToolResponse.text(`Databases (${names.length}):\n${lines.join("\n")}`);
+    }
+}

package/dist/tools/connection/UseConnectionTool.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { BaseTool } from "../BaseTool.js";
+import { EngineCatalog } from "../../domain/Engine.js";
+import { ToolResponse } from "../../formatting/ToolResponse.js";
+/**
+ * Switches to a named profile, optionally overriding its database.
+ *
+ * The override composes two ideas that would otherwise take two calls: "go to
+ * staging, but the analytics database".
+ */
+export class UseConnectionTool extends BaseTool {
+    connections;
+    names;
+    name = "use_connection";
+    description = "Switch to a named connection profile, on any engine. Takes effect immediately, no restart needed";
+    inputSchema = {
+        profile: z.string().describe("Profile name from list_connections"),
+        database: z
+            .string()
+            .optional()
+            .describe("Optional database to use instead of the profile's own database"),
+    };
+    /**
+     * Repoints the reading tools at another server, so not read-only. No data is
+     * altered and repeating the call is a no-op, hence not destructive and
+     * idempotent.
+     */
+    annotations = {
+        title: "Switch Connection Profile",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    };
+    constructor(connections, names) {
+        super();
+        this.connections = connections;
+        this.names = names;
+    }
+    async execute(args) {
+        // The override is checked against the profile's own engine, which may not
+        // be the active one: switching from MySQL to a Redis profile with
+        // database "3" is valid, and MySQL's rules would refuse nothing useful.
+        const profile = this.connections.findProfile(args.profile);
+        if (args.database && profile) {
+            const check = this.names.for(profile.target.engine).validateDatabase(args.database);
+            if (!check.valid) {
+                return ToolResponse.failure(check.error ?? "Invalid database name.");
+            }
+        }
+        // An unknown profile throws UnknownProfileError, which carries the known
+        // names; BaseTool turns it into a tool error. When someone mistypes a
+        // profile, seeing the real list is the fastest route to the fix.
+        const target = await this.connections.useProfile(args.profile, args.database);
+        return ToolResponse.text(`Switched to profile "${args.profile}" (${EngineCatalog.label(target.engine)}) -> ${target.describe()}`);
+    }
+}

package/dist/tools/connection/UseDatabaseTool.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { BaseTool } from "../BaseTool.js";
+import { ToolResponse } from "../../formatting/ToolResponse.js";
+/**
+ * Switches database on the current server.
+ *
+ * The verify-then-commit ordering lives in ConnectionManager, so this tool
+ * cannot get it wrong: a nonexistent database fails the call and leaves the
+ * previous connection working.
+ */
+export class UseDatabaseTool extends BaseTool {
+    connections;
+    names;
+    name = "use_database";
+    description = "Switch the active database on the current server. Takes effect immediately, no restart needed";
+    inputSchema = {
+        database: z.string().describe("Database name to switch to, or the database number on Redis"),
+    };
+    /**
+     * Changes which database the reading tools see, so not read-only. Nothing
+     * in the database is touched, and switching twice to the same name leaves
+     * the same state, hence not destructive and idempotent.
+     */
+    annotations = {
+        title: "Switch Database",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    };
+    constructor(connections, names) {
+        super();
+        this.connections = connections;
+        this.names = names;
+    }
+    async execute(args) {
+        const active = this.connections.requireActiveTarget();
+        const check = this.names.for(active.engine).validateDatabase(args.database);
+        if (!check.valid) {
+            return ToolResponse.failure(check.error ?? "Invalid database name.");
+        }
+        const target = await this.connections.useDatabase(args.database);
+        return ToolResponse.text(`Switched to ${target.describe()}`);
+    }
+}

package/dist/tools/document/AggregateTool.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { DatabaseScopedTool } from "../DatabaseScopedTool.js";
+import { DocumentTool } from "./DocumentTool.js";
+import { ToolResponse } from "../../formatting/ToolResponse.js";
+/**
+ * A MongoDB aggregation pipeline: MongoDB's equivalent of run_query.
+ *
+ * Checked twice, by two different mechanisms: MongoOperatorGuard here refuses
+ * `$out`, `$merge` and server-side JavaScript anywhere in the pipeline, and
+ * the driver's MongoStageAllowlist refuses any stage it does not recognise as
+ * a read.
+ */
+export class AggregateTool extends DocumentTool {
+    rows;
+    name = "aggregate";
+    description = "Run a read-only MongoDB aggregation pipeline on a collection ($out and $merge are not allowed)";
+    annotations = {
+        title: "Run Aggregation Pipeline",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    };
+    inputSchema = {
+        collection: DocumentTool.collectionParam,
+        pipeline: z
+            .array(z.record(z.unknown()))
+            .describe('Pipeline stages as Extended JSON, e.g. [{"$match": {"status": "active"}}, {"$group": {"_id": "$type", "n": {"$sum": 1}}}]'),
+        database: DatabaseScopedTool.databaseParam,
+    };
+    constructor(drivers, names, guard, rows) {
+        super(drivers, names, guard);
+        this.rows = rows;
+    }
+    async read(args, target) {
+        const rejection = this.checkInputs(target, args.collection, { pipeline: args.pipeline });
+        if (rejection) {
+            return rejection;
+        }
+        const driver = await this.drivers.acquireDocument(target, this.name);
+        const result = await driver.aggregate(args.collection, args.pipeline, this.rows.limit);
+        return ToolResponse.text(this.rows.format(result.rows, "Add a $limit stage or a narrower $match", result.truncated));
+    }
+}

package/dist/tools/document/CountDocumentsTool.js

@@ -0,0 +1,32 @@
+import { DatabaseScopedTool } from "../DatabaseScopedTool.js";
+import { DocumentTool } from "./DocumentTool.js";
+import { ToolResponse } from "../../formatting/ToolResponse.js";
+/** An exact count of matching documents. */
+export class CountDocumentsTool extends DocumentTool {
+    name = "count_documents";
+    description = "Count documents in a MongoDB collection that match a filter";
+    annotations = {
+        title: "Count Documents",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    };
+    inputSchema = {
+        collection: DocumentTool.collectionParam,
+        filter: DocumentTool.filterParam,
+        database: DatabaseScopedTool.databaseParam,
+    };
+    constructor(drivers, names, guard) {
+        super(drivers, names, guard);
+    }
+    async read(args, target) {
+        const rejection = this.checkInputs(target, args.collection, { filter: args.filter });
+        if (rejection) {
+            return rejection;
+        }
+        const driver = await this.drivers.acquireDocument(target, this.name);
+        const count = await driver.count(args.collection, args.filter);
+        return ToolResponse.text(`${count} matching document${count === 1 ? "" : "s"} in "${args.collection}".`);
+    }
+}

package/dist/tools/document/DistinctValuesTool.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { DatabaseScopedTool } from "../DatabaseScopedTool.js";
+import { DocumentTool } from "./DocumentTool.js";
+import { ToolResponse } from "../../formatting/ToolResponse.js";
+/** The distinct values of one field: how people find out what a status column holds. */
+export class DistinctValuesTool extends DocumentTool {
+    rows;
+    name = "distinct_values";
+    description = "List the distinct values of a field in a MongoDB collection, optionally within a filter";
+    annotations = {
+        title: "List Distinct Values",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    };
+    inputSchema = {
+        collection: DocumentTool.collectionParam,
+        field: z.string().min(1).describe("Field path, e.g. status or address.city"),
+        filter: DocumentTool.filterParam,
+        database: DatabaseScopedTool.databaseParam,
+    };
+    constructor(drivers, names, guard, rows) {
+        super(drivers, names, guard);
+        this.rows = rows;
+    }
+    async read(args, target) {
+        const rejection = this.checkInputs(target, args.collection, { filter: args.filter });
+        if (rejection) {
+            return rejection;
+        }
+        const driver = await this.drivers.acquireDocument(target, this.name);
+        const values = await driver.distinct(args.collection, args.field, args.filter);
+        return ToolResponse.text(this.rows.format(values, "Narrow the filter"));
+    }
+}

package/dist/tools/document/DocumentTool.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { DatabaseScopedTool } from "../DatabaseScopedTool.js";
+/**
+ * Base for the MongoDB query tools.
+ *
+ * Holds what all four share: the collection argument, the family check, and
+ * the operator guard every filter and pipeline passes through before the
+ * driver sees it.
+ */
+export class DocumentTool extends DatabaseScopedTool {
+    guard;
+    family = "document";
+    static collectionParam = z.string().describe("Collection name");
+    static filterParam = z
+        .record(z.unknown())
+        .default({})
+        .describe('Query filter as MongoDB Extended JSON, e.g. {"status": "active", "_id": {"$oid": "..."}}');
+    constructor(drivers, names, guard) {
+        super(drivers, names);
+        this.guard = guard;
+    }
+    /** The collection name and every filter or pipeline, checked in one place. */
+    checkInputs(target, collection, inputs) {
+        const rejection = this.validateObjectName(target, collection, "collection name");
+        if (rejection) {
+            return rejection;
+        }
+        for (const [label, value] of Object.entries(inputs)) {
+            if (value !== undefined) {
+                const objection = this.reject(this.guard.validate(value, label));
+                if (objection) {
+                    return objection;
+                }
+            }
+        }
+        return null;
+    }
+}

package/dist/tools/document/FindDocumentsTool.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { DatabaseScopedTool } from "../DatabaseScopedTool.js";
+import { DocumentTool } from "./DocumentTool.js";
+import { ToolResponse } from "../../formatting/ToolResponse.js";
+/** MongoDB's `find`: the everyday query. */
+export class FindDocumentsTool extends DocumentTool {
+    rows;
+    name = "find_documents";
+    description = "Find documents in a MongoDB collection with a filter, optional projection and sort";
+    static MAX_LIMIT = 100;
+    annotations = {
+        title: "Find Documents",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    };
+    inputSchema = {
+        collection: DocumentTool.collectionParam,
+        filter: DocumentTool.filterParam,
+        projection: z.record(z.unknown()).optional().describe('Fields to include or exclude, e.g. {"name": 1, "_id": 0}'),
+        sort: z.record(z.unknown()).optional().describe('Sort order, e.g. {"createdAt": -1}'),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(FindDocumentsTool.MAX_LIMIT)
+            .default(20)
+            .describe("Maximum documents to return (1-100, default 20)"),
+        skip: z.number().int().min(0).default(0).describe("Documents to skip, for paging"),
+        database: DatabaseScopedTool.databaseParam,
+    };
+    constructor(drivers, names, guard, rows) {
+        super(drivers, names, guard);
+        this.rows = rows;
+    }
+    async read(args, target) {
+        const rejection = this.checkInputs(target, args.collection, {
+            filter: args.filter,
+            projection: args.projection,
+            sort: args.sort,
+        });
+        if (rejection) {
+            return rejection;
+        }
+        const driver = await this.drivers.acquireDocument(target, this.name);
+        const documents = await driver.find(args.collection, {
+            filter: args.filter,
+            projection: args.projection,
+            sort: args.sort,
+            limit: Math.min(args.limit, FindDocumentsTool.MAX_LIMIT),
+            skip: args.skip,
+        });
+        return ToolResponse.text(this.rows.format(documents, "Narrow the filter or lower the limit"));
+    }
+}

package/dist/tools/keyvalue/RedisCommandTool.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { DatabaseScopedTool } from "../DatabaseScopedTool.js";
+import { ToolResponse } from "../../formatting/ToolResponse.js";
+/**
+ * One read-only Redis command: Redis's equivalent of run_query.
+ *
+ * The command name and its arguments are separate fields rather than one
+ * string, so an argument containing a space or a quote is never re-split,
+ * and there is no command-line syntax to get wrong.
+ */
+export class RedisCommandTool extends DatabaseScopedTool {
+    validator;
+    name = "redis_command";
+    description = "Run one read-only Redis command such as GET, HGETALL, LRANGE, ZRANGE, SCAN, TTL or INFO. Write commands and KEYS are refused";
+    family = "keyvalue";
+    annotations = {
+        title: "Run Read-Only Redis Command",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    };
+    inputSchema = {
+        command: z.string().describe("Command name, e.g. HGETALL"),
+        args: z.array(z.string()).default([]).describe('Arguments, e.g. ["user:42"]'),
+        database: DatabaseScopedTool.databaseParam,
+    };
+    constructor(drivers, names, validator) {
+        super(drivers, names);
+        this.validator = validator;
+    }
+    async read(args, target) {
+        const check = this.validator.validate(args.command, args.args);
+        if (!check.valid || !check.name) {
+            return ToolResponse.failure(check.error ?? "Command rejected.");
+        }
+        const driver = await this.drivers.acquireKeyValue(target, this.name);
+        return ToolResponse.json(await driver.command(check.name, args.args));
+    }
+}