@shibbirweb/mcp-db-read-only 0.1.0 → 1.0.0

package/dist/drivers/sql/MsSqlDriver.js

@@ -23,8 +23,8 @@ export class MsSqlDriver extends BaseDriver {
     dialect = "mssql";
     static SYSTEM_DATABASES = new Set(["master", "tempdb", "model", "msdb"]);
     pool;
-    constructor(target, tuning) {
-        super(target);
+    constructor(target, tuning, tracer) {
+        super(target, tracer);
         this.tuning = tuning;
         this.pool = new LazyResource(() => this.createPool(), (opened) => opened.pool.close());
     }
@@ -95,17 +95,17 @@ export class MsSqlDriver extends BaseDriver {
     async run(text, inputs = {}) {
         const { pool, sql } = await this.pool.get();
         const transaction = new sql.Transaction(pool);
-        await transaction.begin();
+        await this.traced("BEGIN TRANSACTION", undefined, () => transaction.begin(), () => "ok");
         try {
             const request = new sql.Request(transaction);
             for (const [name, value] of Object.entries(inputs)) {
                 request.input(name, value);
             }
-            const result = await request.query(text);
-            return (result.recordset ?? []);
+            const params = Object.keys(inputs).length > 0 ? inputs : undefined;
+            return await this.traced(text, params, async () => ((await request.query(text)).recordset ?? []));
         }
         finally {
-            await transaction.rollback().catch(() => undefined);
+            await this.traced("ROLLBACK", undefined, () => transaction.rollback(), () => "ok").catch(() => undefined);
         }
     }
     async assertExists(name) {

package/dist/drivers/sql/MySqlDriver.js

@@ -31,8 +31,8 @@ export class MySqlDriver extends BaseDriver {
     WHERE TABLE_SCHEMA = COALESCE(?, DATABASE()) AND TABLE_NAME = ? AND REFERENCED_TABLE_NAME IS NOT NULL`;
     static NO_SUCH_TABLE = 1146;
     pool;
-    constructor(target, tuning, logger) {
-        super(target);
+    constructor(target, tuning, tracer, logger) {
+        super(target, tracer);
         this.tuning = tuning;
         this.logger = logger;
         this.pool = new LazyResource(() => this.createPool(), (pool) => pool.end());
@@ -78,8 +78,10 @@ export class MySqlDriver extends BaseDriver {
     /** Placeholders for values wherever the statement allows; identifiers are quoted. */
     async run(sql, params) {
         const pool = await this.pool.get();
-        const [rows] = await pool.query(sql, params);
-        return rows;
+        return this.traced(sql, params, async () => {
+            const [rows] = await pool.query(sql, params);
+            return rows;
+        });
     }
     /**
      * Runs work against one table, turning MySQL's "table doesn't exist" (error
@@ -127,7 +129,7 @@ export class MySqlDriver extends BaseDriver {
             dateStrings: true,
             ssl: this.sslOptions(),
         });
-        new MySqlSessionInitializer(this.tuning.queryTimeoutMs, this.logger).attachTo(pool);
+        new MySqlSessionInitializer(this.tuning.queryTimeoutMs, this.logger, this.tracer, this.label).attachTo(pool);
         return pool;
     }
     /** `?ssl=true` requires TLS; `?ssl-mode=REQUIRED` is accepted as the MySQL spelling. */

package/dist/drivers/sql/MySqlSessionInitializer.js

@@ -12,6 +12,8 @@
 export class MySqlSessionInitializer {
     queryTimeoutMs;
     logger;
+    tracer;
+    engineLabel;
     /**
      * Removes the two sql_mode flags that change how quotes are read, so the
      * server lexes a statement exactly as the validator did.
@@ -38,9 +40,17 @@ export class MySqlSessionInitializer {
     ].reduce((expression, mode) => `REPLACE(${expression}, ',${mode},', ',')`, "CONCAT(',', @@SESSION.sql_mode, ',')")})`;
     /** MariaDB's name for the variable; MySQL rejects it with error 1193. */
     static UNKNOWN_VARIABLE = 1193;
-    constructor(queryTimeoutMs, logger) {
+    /**
+     * @param tracer records each setup statement in the call log, when it is
+     *   on. They run on the pool's own schedule, so they usually appear as
+     *   entries of their own rather than under the call that opened the
+     *   connection.
+     */
+    constructor(queryTimeoutMs, logger, tracer, engineLabel) {
         this.queryTimeoutMs = queryTimeoutMs;
         this.logger = logger;
+        this.tracer = tracer;
+        this.engineLabel = engineLabel;
     }
     /**
      * Hooks the pool's `connection` event, which fires once per physical
@@ -70,7 +80,10 @@ export class MySqlSessionInitializer {
      * gap affects only the timeout, never the read-only mode set above.
      */
     applyTimeout(connection) {
-        connection.query(`SET SESSION MAX_EXECUTION_TIME = ${this.queryTimeoutMs}`, (error) => {
+        const sql = `SET SESSION MAX_EXECUTION_TIME = ${this.queryTimeoutMs}`;
+        const started = Date.now();
+        connection.query(sql, (error) => {
+            this.tracer.record(this.engineLabel, { text: sql }, Date.now() - started, error ?? undefined);
             if (!error) {
                 return;
             }
@@ -91,7 +104,9 @@ export class MySqlSessionInitializer {
      * not.
      */
     apply(connection, sql, description) {
+        const started = Date.now();
         connection.query(sql, (error) => {
+            this.tracer.record(this.engineLabel, { text: sql }, Date.now() - started, error ?? undefined);
             if (error) {
                 this.logger(`could not ${description}: ${String(error)}`);
             }

package/dist/drivers/sql/PostgresDriver.js

@@ -32,8 +32,8 @@ export class PostgresDriver extends BaseDriver {
      */
     static RAW_TEXT_TYPES = new Set([1082, 1083, 1114, 1184, 1266]);
     pool;
-    constructor(target, tuning) {
-        super(target);
+    constructor(target, tuning, tracer) {
+        super(target, tracer);
         this.tuning = tuning;
         this.pool = new LazyResource(() => this.createPool(), (pool) => pool.end());
     }
@@ -106,10 +106,10 @@ export class PostgresDriver extends BaseDriver {
         const client = await pool.connect();
         let broken;
         try {
-            await client.query(`BEGIN TRANSACTION READ ONLY; SET LOCAL statement_timeout = ${this.tuning.queryTimeoutMs}; SET LOCAL standard_conforming_strings = on`);
+            const opening = `BEGIN TRANSACTION READ ONLY; SET LOCAL statement_timeout = ${this.tuning.queryTimeoutMs}; SET LOCAL standard_conforming_strings = on`;
+            await this.traced(opening, undefined, () => client.query(opening), () => "ok");
             const config = { text, values, queryMode: "extended" };
-            const result = await client.query(config);
-            return result.rows;
+            return await this.traced(text, values, async () => (await client.query(config)).rows);
         }
         finally {
             broken = await this.rollback(client);
@@ -120,7 +120,7 @@ export class PostgresDriver extends BaseDriver {
     }
     async rollback(client) {
         try {
-            await client.query("ROLLBACK");
+            await this.traced("ROLLBACK", undefined, () => client.query("ROLLBACK"), () => "ok");
             return undefined;
         }
         catch (error) {

package/dist/drivers/sql/SqliteDriver.js

@@ -134,8 +134,8 @@ export class SqliteDriver extends BaseDriver {
     family = "sql";
     dialect = "sqlite";
     worker;
-    constructor(target, tuning) {
-        super(target);
+    constructor(target, tuning, tracer) {
+        super(target, tracer);
         this.tuning = tuning;
         this.worker = new LazyResource(() => SqliteWorkerHandle.start({ path: target.database, busyTimeoutMs: tuning.connectTimeoutMs }, tuning.connectTimeoutMs), (handle) => handle.terminate());
     }
@@ -190,7 +190,7 @@ export class SqliteDriver extends BaseDriver {
     async run(sql, params = []) {
         const handle = await this.worker.get();
         try {
-            return await handle.run(sql, params, this.tuning.queryTimeoutMs);
+            return await this.traced(sql, params.length > 0 ? params : undefined, () => handle.run(sql, params, this.tuning.queryTimeoutMs));
         }
         catch (error) {
             if (handle.dead) {

package/dist/formatting/JsonSerializer.js

@@ -14,7 +14,8 @@
 export class JsonSerializer {
     /** Enough bytes to recognise a value; the length says how much was omitted. */
     static BINARY_PREVIEW_BYTES = 32;
-    stringify(value) {
+    /** @param indent 2 for reading, 0 for one-line JSON such as a log entry. */
+    stringify(value, indent = 2) {
         const serializer = this;
         return JSON.stringify(value, 
         // A function rather than an arrow, because the replacer receives the
@@ -22,7 +23,7 @@ export class JsonSerializer {
         // the original Buffer.
         function (key, replaced) {
             return serializer.replace(this[key], replaced);
-        }, 2) ?? "null";
+        }, indent || undefined) ?? "null";
     }
     replace(original, replaced) {
         if (typeof original === "bigint") {

package/dist/index.js

@@ -3,13 +3,22 @@ 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.
+ * With no arguments, which is how every MCP client runs it, this is the MCP
+ * server. `viewer` runs the standalone live log viewer instead; it is loaded
+ * only then, so it costs the MCP server's startup nothing.
+ *
+ * For the MCP server 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 [command, ...rest] = process.argv.slice(2);
+if (command === "viewer") {
+    const { ViewerCommand } = await import("./cli/ViewerCommand.js");
+    process.exit(await new ViewerCommand().run(rest));
+}
 const application = new ApplicationFactory();
 await application.create().start();

package/dist/logging/CallLogger.js

@@ -0,0 +1,139 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Redactor } from "./Redactor.js";
+/**
+ * The call log: one entry per tool call, with every statement the drivers
+ * sent while serving it.
+ *
+ * It is both halves of the logging interface. BaseTool hands it each call as
+ * a ToolCallObserver, and drivers report each statement to it as a
+ * StatementTracer. The two meet through AsyncLocalStorage: a call runs inside
+ * its own context, so a statement reported anywhere beneath it, however many
+ * awaits deep, lands on the right call without any id being passed through
+ * the drivers. Calls handled concurrently each keep their own statements.
+ *
+ * A statement reported with no call around it (a MySQL connection's session
+ * setup, fired by the pool) is written as an entry of its own.
+ *
+ * Each record goes to every channel: text to stderr or a file, the live
+ * browser viewer, or both.
+ *
+ * Logging can never break a call. Any failure in a channel is caught; the
+ * first one is reported once through the diagnostic logger and that channel
+ * is then switched off for the rest of the process, rather than failing, say,
+ * on every call once a disk fills up. The other channels carry on.
+ */
+export class CallLogger {
+    channels;
+    describeConnection;
+    warn;
+    describeClient;
+    redactor;
+    clock;
+    context = new AsyncLocalStorage();
+    nextId = 1;
+    disabled = new Set();
+    constructor(channels, describeConnection, warn, 
+    /** The MCP client's name, known once it has completed the handshake. */
+    describeClient = () => null, redactor = new Redactor(), clock = () => Date.now()) {
+        this.channels = channels;
+        this.describeConnection = describeConnection;
+        this.warn = warn;
+        this.describeClient = describeClient;
+        this.redactor = redactor;
+        this.clock = clock;
+    }
+    async observe(tool, args, run) {
+        const id = this.nextId++;
+        const started = this.clock();
+        const connection = this.safely(() => this.describeConnection(), null);
+        const context = { statements: [] };
+        const result = await this.context.run(context, run);
+        const record = this.safely(() => ({
+            id,
+            tool,
+            pid: process.pid,
+            client: this.safely(() => this.describeClient(), null),
+            at: new Date(started),
+            durationMs: this.clock() - started,
+            connection,
+            input: this.redactor.redact(args),
+            output: result.content.map((block) => block.text).join("\n"),
+            failed: Boolean(result.isError),
+            statements: context.statements,
+        }), null);
+        if (record) {
+            this.publish((channel) => channel.onCall(record));
+        }
+        return result;
+    }
+    async trace(engine, statement, run, describe = CallLogger.describe) {
+        const started = this.clock();
+        try {
+            const result = await run();
+            this.add(engine, statement, started, this.safely(() => describe(result), "ok"), false);
+            return result;
+        }
+        catch (error) {
+            this.add(engine, statement, started, CallLogger.reason(error), true);
+            throw error;
+        }
+    }
+    record(engine, statement, durationMs, error) {
+        const started = this.clock() - durationMs;
+        this.add(engine, statement, started, error ? CallLogger.reason(error) : "ok", Boolean(error));
+    }
+    /** The default outcome: a row count for arrays, "ok" for everything else. */
+    static describe(result) {
+        if (Array.isArray(result)) {
+            return `${result.length} row${result.length === 1 ? "" : "s"}`;
+        }
+        if (typeof result === "number") {
+            return String(result);
+        }
+        return "ok";
+    }
+    add(engine, statement, started, outcome, failed) {
+        const record = {
+            pid: process.pid,
+            client: this.safely(() => this.describeClient(), null),
+            engine,
+            text: statement.text,
+            params: statement.params,
+            at: new Date(started),
+            durationMs: this.clock() - started,
+            outcome,
+            failed,
+        };
+        const current = this.context.getStore();
+        if (current) {
+            current.statements.push(record);
+            return;
+        }
+        this.publish((channel) => channel.onStatement(record));
+    }
+    publish(deliver) {
+        for (const channel of this.channels) {
+            if (this.disabled.has(channel)) {
+                continue;
+            }
+            try {
+                deliver(channel);
+            }
+            catch (error) {
+                this.disabled.add(channel);
+                this.warn(`call logging to ${channel.description} stopped after a failure: ${CallLogger.reason(error)}`);
+            }
+        }
+    }
+    safely(read, fallback) {
+        try {
+            return read();
+        }
+        catch {
+            return fallback;
+        }
+    }
+    static reason(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}

package/dist/logging/LogChannel.js

@@ -0,0 +1,18 @@
+/** Formats records as text and writes them to a sink. */
+export class TextLogChannel {
+    sink;
+    formatter;
+    constructor(sink, formatter) {
+        this.sink = sink;
+        this.formatter = formatter;
+    }
+    get description() {
+        return this.sink.description;
+    }
+    onCall(call) {
+        this.sink.write(this.formatter.formatCall(call));
+    }
+    onStatement(statement) {
+        this.sink.write(this.formatter.formatStatement(statement));
+    }
+}

package/dist/logging/LogFormatter.js

@@ -0,0 +1,80 @@
+import { JsonSerializer } from "../formatting/JsonSerializer.js";
+import { RecordJson } from "./RecordJson.js";
+/**
+ * For reading: one boxed block per call, with the input, every statement the
+ * drivers sent, and the full output, each indented under its heading.
+ *
+ * ```
+ * ┌─ #3 run_query · ok · 38 ms · 2026-09-25T10:14:03.221Z
+ * │ connection  dev (MySQL) mysql://root@127.0.0.1:3306/app
+ * │ input
+ * │   { "query": "SELECT COUNT(*) AS n FROM members" }
+ * │ statements (1)
+ * │   1. MySQL · 12 ms · 1 row
+ * │      SELECT COUNT(*) AS n FROM members
+ * │ output
+ * │   [ { "n": 17440 } ]
+ * └─
+ * ```
+ */
+export class PrettyLogFormatter {
+    serializer;
+    constructor(serializer = new JsonSerializer()) {
+        this.serializer = serializer;
+    }
+    formatCall(call) {
+        const lines = [];
+        const status = call.failed ? "FAILED" : "ok";
+        lines.push(`┌─ #${call.id} ${call.tool} · ${status} · ${call.durationMs} ms · ${call.at.toISOString()}`);
+        lines.push(`│ connection  ${call.connection ?? "none"}`);
+        lines.push(`│ process     ${call.client ?? "unknown client"}, pid ${call.pid}`);
+        lines.push("│ input");
+        lines.push(...this.indent(this.serializer.stringify(call.input), "│   "));
+        if (call.statements.length > 0) {
+            lines.push(`│ statements (${call.statements.length})`);
+            call.statements.forEach((statement, index) => {
+                lines.push(`│   ${index + 1}. ${this.summary(statement)}`);
+                lines.push(...this.statementBody(statement, "│      "));
+            });
+        }
+        lines.push(call.failed ? "│ error" : "│ output");
+        lines.push(...this.indent(call.output, "│   "));
+        lines.push("└─");
+        return `${lines.join("\n")}\n`;
+    }
+    formatStatement(statement) {
+        const lines = [`· statement outside a tool call · ${this.summary(statement)} · ${statement.at.toISOString()}`];
+        lines.push(...this.statementBody(statement, "    "));
+        return `${lines.join("\n")}\n`;
+    }
+    summary(statement) {
+        const outcome = statement.failed ? `FAILED: ${statement.outcome}` : statement.outcome;
+        return `${statement.engine} · ${statement.durationMs} ms · ${outcome}`;
+    }
+    statementBody(statement, prefix) {
+        const lines = this.indent(statement.text, prefix);
+        if (statement.params !== undefined) {
+            lines.push(...this.indent(`params ${this.serializer.stringify(statement.params, 0)}`, prefix));
+        }
+        return lines;
+    }
+    indent(text, prefix) {
+        return text.split("\n").map((line) => `${prefix}${line}`);
+    }
+}
+/**
+ * For machines: one JSON object per line, so `grep`, `jq` and log shippers
+ * can read it without knowing anything about this server.
+ */
+export class JsonLogFormatter {
+    serializer;
+    constructor(serializer = new JsonSerializer()) {
+        this.serializer = serializer;
+    }
+    formatCall(call) {
+        return `${this.serializer.stringify(RecordJson.call(call), 0)}\n`;
+    }
+    formatStatement(statement) {
+        return `${this.serializer.stringify(RecordJson.statement(statement), 0)}\n`;
+    }
+}

package/dist/logging/LogRecords.js

@@ -0,0 +1,7 @@
+/**
+ * What the call log records, independent of how it is written out.
+ *
+ * Kept as plain data so the two formatters (pretty and JSON) render exactly
+ * the same facts, and a test can assert on a record without parsing text.
+ */
+export {};

package/dist/logging/LogSink.js

@@ -0,0 +1,38 @@
+import { appendFileSync } from "node:fs";
+/**
+ * The MCP client's own log.
+ *
+ * stderr, never stdout: stdout carries the JSON-RPC stream, and one log line
+ * there would corrupt the protocol. Claude Code, for one, keeps each MCP
+ * server's stderr in its MCP logs.
+ */
+export class StderrSink {
+    description = "stderr";
+    write(entry) {
+        process.stderr.write(entry.endsWith("\n") ? entry : `${entry}\n`);
+    }
+}
+/**
+ * A file, appended to.
+ *
+ * Synchronous on purpose. Shutdown ends with `process.exit`, which does not
+ * wait for a buffered stream to drain, so an asynchronous writer loses the
+ * last calls of a session: usually the ones someone opened the log to find.
+ * The cost is a blocking write per call, which is small next to a database
+ * round trip.
+ *
+ * Created readable by the owner only, since with logging on it holds every
+ * query and every result.
+ */
+export class FileSink {
+    path;
+    constructor(path) {
+        this.path = path;
+    }
+    get description() {
+        return this.path;
+    }
+    write(entry) {
+        appendFileSync(this.path, entry.endsWith("\n") ? entry : `${entry}\n`, { mode: 0o600 });
+    }
+}

package/dist/logging/RecordJson.js

@@ -0,0 +1,39 @@
+/**
+ * The one JSON shape of a record, used everywhere a record leaves the process
+ * as data: JSON log lines, the saved files, and the live viewer.
+ *
+ * One definition, so a file written today reads back in the viewer exactly
+ * as a live entry does, and a field added here appears in all three.
+ */
+export class RecordJson {
+    static call(call) {
+        return {
+            type: "call",
+            id: call.id,
+            tool: call.tool,
+            at: call.at.toISOString(),
+            durationMs: call.durationMs,
+            failed: call.failed,
+            pid: call.pid,
+            client: call.client,
+            connection: call.connection,
+            input: call.input,
+            statements: call.statements.map((statement) => RecordJson.statementFields(statement)),
+            output: call.output,
+        };
+    }
+    static statement(statement) {
+        return { type: "statement", ...RecordJson.statementFields(statement), pid: statement.pid, client: statement.client };
+    }
+    static statementFields(statement) {
+        return {
+            engine: statement.engine,
+            at: statement.at.toISOString(),
+            durationMs: statement.durationMs,
+            failed: statement.failed,
+            outcome: statement.outcome,
+            text: statement.text,
+            params: statement.params,
+        };
+    }
+}

package/dist/logging/Redactor.js

@@ -0,0 +1,95 @@
+/**
+ * Removes credentials from tool arguments before they are logged.
+ *
+ * Always applied, with no switch to turn it off. The call log exists to show
+ * what an assistant asked for, and a password is never part of that answer;
+ * a log file is also exactly the kind of thing that ends up attached to an
+ * issue or pasted into a chat.
+ *
+ * Two shapes are caught:
+ *
+ * - **An argument whose name looks like a secret** (`password`, `api_key`,
+ *   `token`...), at any depth. The value is replaced outright.
+ * - **A connection URL anywhere in a string**, whose password and whose
+ *   secret-looking query parameters are masked. The URL is split the same way
+ *   ConnectionUrlParser splits it, so what is masked is exactly what the
+ *   parser would have used as the password.
+ */
+export class Redactor {
+    static MASK = "***";
+    /** The same test ConnectionUrlParser uses to keep secret options out of displayed strings. */
+    static SECRET_NAME = /(pass|secret|token|api[_-]?key|credential)/i;
+    static URL_START = /^[A-Za-z][A-Za-z0-9+.-]*:\/\//;
+    static MAX_DEPTH = 32;
+    redact(value, depth = 0) {
+        if (depth > Redactor.MAX_DEPTH) {
+            return "[nested too deeply to log]";
+        }
+        if (typeof value === "string") {
+            return this.redactUrl(value);
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => this.redact(item, depth + 1));
+        }
+        if (value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+            const out = {};
+            for (const [key, child] of Object.entries(value)) {
+                out[key] = Redactor.SECRET_NAME.test(key) && child !== "" && child != null
+                    ? Redactor.MASK
+                    : this.redact(child, depth + 1);
+            }
+            return out;
+        }
+        return value;
+    }
+    /**
+     * `scheme://user:password@host/db?api_key=...` becomes
+     * `scheme://user:***@host/db?api_key=***`. Anything not shaped like a URL
+     * is returned unchanged.
+     */
+    redactUrl(text) {
+        const scheme = Redactor.URL_START.exec(text);
+        if (!scheme) {
+            return text;
+        }
+        const prefix = scheme[0];
+        const rest = text.slice(prefix.length);
+        const authorityEnd = this.firstIndexOf(rest, ["/", "?", "#"]);
+        const authority = authorityEnd === -1 ? rest : rest.slice(0, authorityEnd);
+        const tail = authorityEnd === -1 ? "" : rest.slice(authorityEnd);
+        return `${prefix}${this.maskUserInfo(authority)}${this.maskQuery(tail)}`;
+    }
+    maskUserInfo(authority) {
+        const at = authority.lastIndexOf("@");
+        if (at === -1) {
+            return authority;
+        }
+        const userInfo = authority.slice(0, at);
+        const colon = userInfo.indexOf(":");
+        if (colon === -1 || colon === userInfo.length - 1) {
+            return authority;
+        }
+        return `${userInfo.slice(0, colon + 1)}${Redactor.MASK}${authority.slice(at)}`;
+    }
+    maskQuery(tail) {
+        const queryAt = tail.indexOf("?");
+        if (queryAt === -1) {
+            return tail;
+        }
+        const hashAt = tail.indexOf("#", queryAt);
+        const query = tail.slice(queryAt + 1, hashAt === -1 ? undefined : hashAt);
+        const masked = query
+            .split("&")
+            .map((pair) => {
+            const equals = pair.indexOf("=");
+            const name = equals === -1 ? pair : pair.slice(0, equals);
+            return equals !== -1 && Redactor.SECRET_NAME.test(name) ? `${name}=${Redactor.MASK}` : pair;
+        })
+            .join("&");
+        return `${tail.slice(0, queryAt + 1)}${masked}${hashAt === -1 ? "" : tail.slice(hashAt)}`;
+    }
+    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/logging/StatementTracer.js

@@ -0,0 +1,9 @@
+/** The tracer when logging is off: no records, no timing, no overhead beyond one call. */
+export class SilentTracer {
+    trace(_engine, _statement, run) {
+        return run();
+    }
+    record() {
+        return;
+    }
+}

package/dist/logging/ToolCallObserver.js

@@ -0,0 +1,6 @@
+/** The observer when logging is off. */
+export class SilentObserver {
+    observe(_tool, _args, run) {
+        return run();
+    }
+}