taurusdb-core 0.4.0 → 0.5.0-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TaurusDB MCP contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -4,7 +4,7 @@ Shared TaurusDB data-plane engine for:
 
 - schema discovery
 - readonly and mutation SQL execution
-- SQL guardrails and confirmation flow
+- SQL guardrails and external operator-signed approval flow
 - TaurusDB capability detection
 - diagnostics workflows
 
@@ -19,3 +19,5 @@ npm install taurusdb-core
 - Requires Node.js `>= 20`
 - This is the shared engine package
 - Most end users should install `taurusdb-mcp` instead
+- TLS verification, least-privilege credentials, bounded results, and JSONL
+  auditing are enabled as production safety controls

package/dist/audit/jsonl-writer.d.ts

@@ -0,0 +1,47 @@
+export type AuditDecision = "allowed" | "blocked" | "approval_required" | "approval_denied" | "failed";
+export interface AuditEvent {
+    timestamp: string;
+    task_id: string;
+    tool: string;
+    actor: string;
+    datasource?: string;
+    database?: string;
+    host?: string;
+    port?: number;
+    project_id?: string;
+    instance_id?: string;
+    node_id?: string;
+    sql_hash?: string;
+    raw_sql?: string;
+    decision: AuditDecision;
+    outcome: "success" | "error";
+    error_code?: string;
+    duration_ms: number;
+}
+export interface AuditWriter {
+    write(event: AuditEvent): Promise<void>;
+    close(): Promise<void>;
+}
+export interface JsonlAuditWriterOptions {
+    logPath: string;
+    syncWrites?: boolean;
+    maxBytes?: number;
+    maxFiles?: number;
+}
+export declare class JsonlAuditWriter implements AuditWriter {
+    private handle;
+    private readonly logPath;
+    private readonly syncWrites;
+    private readonly maxBytes;
+    private readonly maxFiles;
+    private currentBytes;
+    private pending;
+    private closed;
+    private constructor();
+    static create(options: JsonlAuditWriterOptions): Promise<JsonlAuditWriter>;
+    private rotate;
+    private writeLine;
+    write(event: AuditEvent): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function createJsonlAuditWriter(options: JsonlAuditWriterOptions): Promise<JsonlAuditWriter>;

package/dist/audit/jsonl-writer.js

@@ -0,0 +1,124 @@
+import { constants } from "node:fs";
+import { mkdir, open, rename, rm, } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+function expandHome(input) {
+    if (input === "~") {
+        return os.homedir();
+    }
+    return input.startsWith("~/") ? path.join(os.homedir(), input.slice(2)) : input;
+}
+export class JsonlAuditWriter {
+    handle;
+    logPath;
+    syncWrites;
+    maxBytes;
+    maxFiles;
+    currentBytes;
+    pending = Promise.resolve();
+    closed = false;
+    constructor(opened, logPath, syncWrites, maxBytes, maxFiles) {
+        this.handle = opened.handle;
+        this.currentBytes = opened.size;
+        this.logPath = logPath;
+        this.syncWrites = syncWrites;
+        this.maxBytes = maxBytes;
+        this.maxFiles = maxFiles;
+    }
+    static async create(options) {
+        const logPath = path.resolve(expandHome(options.logPath));
+        await mkdir(path.dirname(logPath), { recursive: true, mode: 0o700 });
+        const opened = await openAuditFile(logPath);
+        const maxBytes = options.maxBytes ?? 104857600;
+        const maxFiles = options.maxFiles ?? 10;
+        if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) {
+            await opened.handle.close();
+            throw new Error("Audit maxBytes must be a positive safe integer.");
+        }
+        if (!Number.isSafeInteger(maxFiles) || maxFiles <= 0 || maxFiles > 100) {
+            await opened.handle.close();
+            throw new Error("Audit maxFiles must be an integer between 1 and 100.");
+        }
+        return new JsonlAuditWriter(opened, logPath, options.syncWrites ?? true, maxBytes, maxFiles);
+    }
+    async rotate() {
+        if (this.syncWrites) {
+            await this.handle.sync();
+        }
+        await this.handle.close();
+        try {
+            await rm(`${this.logPath}.${this.maxFiles}`, { force: true });
+            for (let index = this.maxFiles - 1; index >= 1; index -= 1) {
+                const source = `${this.logPath}.${index}`;
+                const destination = `${this.logPath}.${index + 1}`;
+                try {
+                    await rm(destination, { force: true });
+                    await rename(source, destination);
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT") {
+                        throw error;
+                    }
+                }
+            }
+            await rm(`${this.logPath}.1`, { force: true });
+            await rename(this.logPath, `${this.logPath}.1`);
+            const opened = await openAuditFile(this.logPath);
+            this.handle = opened.handle;
+            this.currentBytes = opened.size;
+        }
+        catch (error) {
+            const reopened = await openAuditFile(this.logPath);
+            this.handle = reopened.handle;
+            this.currentBytes = reopened.size;
+            throw error;
+        }
+    }
+    async writeLine(line) {
+        const lineBytes = Buffer.byteLength(line, "utf8");
+        if (this.currentBytes > 0 && this.currentBytes + lineBytes > this.maxBytes) {
+            await this.rotate();
+        }
+        await this.handle.write(line, undefined, "utf8");
+        this.currentBytes += lineBytes;
+        if (this.syncWrites) {
+            await this.handle.sync();
+        }
+    }
+    write(event) {
+        if (this.closed) {
+            return Promise.reject(new Error("Audit writer is closed."));
+        }
+        const line = `${JSON.stringify(event)}\n`;
+        const next = this.pending.then(() => this.writeLine(line));
+        this.pending = next.catch(() => undefined);
+        return next;
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        await this.pending;
+        await this.handle.close();
+    }
+}
+async function openAuditFile(logPath) {
+    const noFollow = typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0;
+    const handle = await open(logPath, constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | noFollow, 0o600);
+    try {
+        const fileStat = await handle.stat();
+        if (!fileStat.isFile()) {
+            throw new Error("Audit log target must be a regular file.");
+        }
+        await handle.chmod(0o600);
+        return { handle, size: fileStat.size };
+    }
+    catch (error) {
+        await handle.close();
+        throw error;
+    }
+}
+export function createJsonlAuditWriter(options) {
+    return JsonlAuditWriter.create(options);
+}

package/dist/auth/sql-profile-loader/env-source.js

@@ -60,6 +60,13 @@ export function parseEnvProfile(env) {
     if (!passwordRef) {
         throw new Error("Missing SQL password in environment. Set TAURUSDB_SQL_PASSWORD or include it in DSN.");
     }
+    const mutationUsername = asString(env.TAURUSDB_SQL_MUTATION_USER);
+    const mutationPasswordRef = Object.hasOwn(env, "TAURUSDB_SQL_MUTATION_PASSWORD")
+        ? parseCredentialRef(env.TAURUSDB_SQL_MUTATION_PASSWORD, "TAURUSDB_SQL_MUTATION_PASSWORD")
+        : undefined;
+    if ((mutationUsername && !mutationPasswordRef) || (!mutationUsername && mutationPasswordRef)) {
+        throw new Error("Mutation credentials require both TAURUSDB_SQL_MUTATION_USER and TAURUSDB_SQL_MUTATION_PASSWORD.");
+    }
     const poolSize = asInteger(env.TAURUSDB_SQL_POOL_SIZE);
     if (poolSize !== undefined && poolSize <= 0) {
         throw new Error("Invalid TAURUSDB_SQL_POOL_SIZE: must be positive.");
@@ -74,6 +81,9 @@ export function parseEnvProfile(env) {
             username,
             password: passwordRef,
         },
+        mutationUser: mutationUsername && mutationPasswordRef
+            ? { username: mutationUsername, password: mutationPasswordRef }
+            : undefined,
         poolSize,
     });
 }

package/dist/auth/sql-profile-loader/parsing.js

@@ -190,11 +190,13 @@ export function parseProfileRecord(name, value, context) {
         throw new Error(`Invalid datasource profile ${name} in ${context}: port must be positive.`);
     }
     const database = asString(value.database);
+    const instanceId = asString(value.instanceId ?? value.instance_id);
+    const nodeId = asString(value.nodeId ?? value.node_id);
     const poolSize = asInteger(value.poolSize);
     if (poolSize !== undefined && poolSize <= 0) {
         throw new Error(`Invalid datasource profile ${name} in ${context}: poolSize must be positive.`);
     }
-    // Backward compatibility for older profile field names. New configs should use `user`.
+    // `user` is the read-only credential. Keep older read-only aliases for compatibility.
     const userRaw = value.user ??
         value.readonlyUser ??
         value.readonly ??
@@ -203,6 +205,10 @@ export function parseProfileRecord(name, value, context) {
         throw new Error(`Invalid datasource profile ${name} in ${context}: missing user.`);
     }
     const user = parseUserCredential(userRaw, `${context}.${name}.user`);
+    const mutationUserRaw = value.mutationUser ?? value.writeUser ?? value.rwUser;
+    const mutationUser = mutationUserRaw === undefined
+        ? undefined
+        : parseUserCredential(mutationUserRaw, `${context}.${name}.mutationUser`);
     const tls = parseTlsOptions(value.tls, `${context}.${name}.tls`);
     return withRedactedToString({
         name,
@@ -210,7 +216,10 @@ export function parseProfileRecord(name, value, context) {
         host,
         port,
         database,
+        instanceId,
+        nodeId,
         user,
+        mutationUser,
         tls,
         poolSize,
     });

package/dist/auth/sql-profile-loader/runtime-override.d.ts

@@ -5,6 +5,7 @@ export declare class RuntimeOverrideProfileLoader implements RuntimeTargetProfil
     private readonly runtimeTargets;
     constructor(base: ProfileLoader);
     setRuntimeTarget(name: string, target: RuntimeDataSourceTarget): void;
+    clearRuntimeUser(name: string): void;
     clearRuntimeTarget(name: string): void;
     clearAllRuntimeTargets(): void;
     getRuntimeTarget(name: string): RuntimeDataSourceTarget | undefined;

package/dist/auth/sql-profile-loader/runtime-override.js

@@ -8,6 +8,9 @@ export function applyRuntimeTarget(profile, target) {
         host: target.host ?? profile.host,
         port: target.port ?? profile.port,
         database: target.database ?? profile.database,
+        instanceId: target.instanceId ?? profile.instanceId,
+        nodeId: target.nodeId ?? profile.nodeId,
+        user: target.user ?? profile.user,
     });
 }
 export class RuntimeOverrideProfileLoader {
@@ -18,6 +21,9 @@ export class RuntimeOverrideProfileLoader {
     }
     setRuntimeTarget(name, target) {
         const current = this.runtimeTargets.get(name);
+        const targetChanged = (target.host !== undefined && target.host !== current?.host) ||
+            (target.instanceId !== undefined && target.instanceId !== current?.instanceId);
+        const user = target.user ?? (targetChanged ? undefined : current?.user);
         const next = {
             host: target.host ?? current?.host,
             port: target.port ?? current?.port,
@@ -25,6 +31,17 @@ export class RuntimeOverrideProfileLoader {
             instanceId: target.instanceId ?? current?.instanceId,
             nodeId: target.nodeId ?? current?.nodeId,
         };
+        if (user) {
+            next.user = user;
+        }
+        this.runtimeTargets.set(name, next);
+    }
+    clearRuntimeUser(name) {
+        const current = this.runtimeTargets.get(name);
+        if (!current) {
+            return;
+        }
+        const { user: _user, ...next } = current;
         this.runtimeTargets.set(name, next);
     }
     clearRuntimeTarget(name) {
@@ -34,7 +51,8 @@ export class RuntimeOverrideProfileLoader {
         this.runtimeTargets.clear();
     }
     getRuntimeTarget(name) {
-        return this.runtimeTargets.get(name);
+        const target = this.runtimeTargets.get(name);
+        return target ? { ...target } : undefined;
     }
     async load() {
         const loaded = await this.base.load();

package/dist/auth/sql-profile-loader/types.d.ts

@@ -31,7 +31,12 @@ export interface DataSourceProfile {
     host?: string;
     port: number;
     database?: string;
+    instanceId?: string;
+    nodeId?: string;
+    /** Read-only credential used by discovery, diagnostics, and query tools. */
     user?: UserCredential;
+    /** Separate credential required for mutation tools. No fallback is allowed. */
+    mutationUser?: UserCredential;
     tls?: TlsOptions;
     poolSize?: number;
     toString(): string;
@@ -45,11 +50,13 @@ export interface RuntimeDataSourceTarget {
     host?: string;
     port?: number;
     database?: string;
+    user?: UserCredential;
     instanceId?: string;
     nodeId?: string;
 }
 export interface RuntimeTargetProfileLoader extends ProfileLoader {
     setRuntimeTarget(name: string, target: RuntimeDataSourceTarget): void;
+    clearRuntimeUser(name: string): void;
     clearRuntimeTarget(name: string): void;
     clearAllRuntimeTargets(): void;
     getRuntimeTarget(name: string): RuntimeDataSourceTarget | undefined;

package/dist/capability/probe.js

@@ -111,7 +111,9 @@ export class CapabilityProbeImpl {
         this.connectionPool = options.connectionPool;
     }
     async probe(ctx) {
-        const session = await this.connectionPool.acquire(ctx.datasource, "ro");
+        const session = await this.connectionPool.acquire(ctx.datasource, "ro", {
+            database: ctx.database,
+        });
         try {
             const variables = await collectVariables(session);
             const kernelInfo = await detectKernelInfo(session, variables);

package/dist/cloud/auth.d.ts

@@ -9,6 +9,7 @@ export interface HuaweiCloudAuthOptions {
     domainSuffix?: string;
     iamEndpoint?: string;
     language?: "en-us" | "zh-cn";
+    allowedEndpointHosts?: string[];
     credentialProvider?: HuaweiCloudCredentialProvider;
 }
 export interface HuaweiCloudCredentials {

package/dist/cloud/auth.js

@@ -3,6 +3,24 @@ import { createSystemCredentialProvider } from "./keychain.js";
 function readString(value) {
     return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
+function validateHuaweiCloudUrl(url, auth) {
+    if (url.protocol !== "https:") {
+        throw new Error("Huawei Cloud API endpoints must use HTTPS.");
+    }
+    if (url.username || url.password) {
+        throw new Error("Huawei Cloud API endpoints must not contain credentials.");
+    }
+    const hostname = url.hostname.toLowerCase().replace(/\.$/, "");
+    const suffix = (readString(auth.domainSuffix) ?? "myhuaweicloud.com")
+        .toLowerCase()
+        .replace(/^\.+|\.+$/g, "");
+    const explicitHosts = new Set((auth.allowedEndpointHosts ?? []).map((host) => host.toLowerCase().replace(/\.$/, "")));
+    if (hostname !== suffix &&
+        !hostname.endsWith(`.${suffix}`) &&
+        !explicitHosts.has(hostname)) {
+        throw new Error(`Huawei Cloud API endpoint host is not allowed: ${hostname}.`);
+    }
+}
 function sha256Hex(value) {
     return createHash("sha256").update(value, "utf8").digest("hex");
 }
@@ -88,6 +106,7 @@ export async function fetchHuaweiCloud(options) {
     const fetchImpl = options.fetchImpl ?? fetch;
     const method = options.method ?? "GET";
     const url = new URL(options.url);
+    validateHuaweiCloudUrl(url, options.auth);
     const body = options.body ?? "";
     const authToken = readString(options.auth.authToken);
     const headers = new Headers(options.headers);
@@ -198,6 +217,24 @@ export function getHuaweiCloudAuthFromConfig(config) {
         domainSuffix: config.cloud?.domainSuffix,
         iamEndpoint: config.cloud?.iamEndpoint,
         language: config.cloud?.language,
+        allowedEndpointHosts: [
+            config.cloud?.apiEndpoint,
+            config.cloud?.iamEndpoint,
+            config.cloud?.kmsEndpoint,
+            config.cloud?.csmsEndpoint,
+            config.slowSqlSource?.taurusApi?.endpoint,
+            config.slowSqlSource?.das?.endpoint,
+            config.metricsSource?.ces?.endpoint,
+        ]
+            .filter((value) => Boolean(value))
+            .flatMap((value) => {
+            try {
+                return [new URL(value).hostname];
+            }
+            catch {
+                return [];
+            }
+        }),
         credentialProvider,
     };
 }

package/dist/config/env.js

@@ -147,10 +147,24 @@ export function buildRawConfigFromEnv(env) {
             maxColumns: parseInteger(env.TAURUSDB_MCP_MAX_COLUMNS, "TAURUSDB_MCP_MAX_COLUMNS"),
             maxStatementMs: parseInteger(env.TAURUSDB_MCP_MAX_STATEMENT_MS, "TAURUSDB_MCP_MAX_STATEMENT_MS"),
             maxFieldChars: parseInteger(env.TAURUSDB_MCP_MAX_FIELD_CHARS, "TAURUSDB_MCP_MAX_FIELD_CHARS"),
+            maxResultBytes: parseInteger(env.TAURUSDB_MCP_MAX_RESULT_BYTES, "TAURUSDB_MCP_MAX_RESULT_BYTES"),
+            maxBlobBytes: parseInteger(env.TAURUSDB_MCP_MAX_BLOB_BYTES, "TAURUSDB_MCP_MAX_BLOB_BYTES"),
+            maxConcurrentQueries: parseInteger(env.TAURUSDB_MCP_MAX_CONCURRENT_QUERIES, "TAURUSDB_MCP_MAX_CONCURRENT_QUERIES"),
+            maxQueuedQueries: parseInteger(env.TAURUSDB_MCP_MAX_QUEUED_QUERIES, "TAURUSDB_MCP_MAX_QUEUED_QUERIES"),
+            queueTimeoutMs: parseInteger(env.TAURUSDB_MCP_QUEUE_TIMEOUT_MS, "TAURUSDB_MCP_QUEUE_TIMEOUT_MS"),
         },
         audit: {
             logPath: expandTildePath(readString(env.TAURUSDB_MCP_AUDIT_LOG_PATH)),
             includeRawSql: parseBoolean(env.TAURUSDB_MCP_AUDIT_INCLUDE_RAW_SQL, "TAURUSDB_MCP_AUDIT_INCLUDE_RAW_SQL"),
+            maxBytes: parseInteger(env.TAURUSDB_MCP_AUDIT_MAX_BYTES, "TAURUSDB_MCP_AUDIT_MAX_BYTES"),
+            maxFiles: parseInteger(env.TAURUSDB_MCP_AUDIT_MAX_FILES, "TAURUSDB_MCP_AUDIT_MAX_FILES"),
+        },
+        security: {
+            mutationsEnabled: parseBoolean(env.TAURUSDB_ENABLE_MUTATIONS, "TAURUSDB_ENABLE_MUTATIONS"),
+            dynamicTargetsEnabled: parseBoolean(env.TAURUSDB_ENABLE_DYNAMIC_TARGETS, "TAURUSDB_ENABLE_DYNAMIC_TARGETS"),
+            requireTls: parseBoolean(env.TAURUSDB_REQUIRE_TLS, "TAURUSDB_REQUIRE_TLS"),
+            approvalSecretPath: expandTildePath(readString(env.TAURUSDB_MUTATION_APPROVAL_SECRET_FILE)),
+            approvalTtlSeconds: parseInteger(env.TAURUSDB_MUTATION_APPROVAL_TTL_SECONDS, "TAURUSDB_MUTATION_APPROVAL_TTL_SECONDS"),
         },
         slowSqlSource: {
             taurusApi: {

package/dist/config/schema.d.ts

@@ -62,26 +62,66 @@ export declare const ConfigSchema: z.ZodObject<{
         maxColumns: z.ZodDefault<z.ZodNumber>;
         maxStatementMs: z.ZodDefault<z.ZodNumber>;
         maxFieldChars: z.ZodDefault<z.ZodNumber>;
+        maxResultBytes: z.ZodDefault<z.ZodNumber>;
+        maxBlobBytes: z.ZodDefault<z.ZodNumber>;
+        maxConcurrentQueries: z.ZodDefault<z.ZodNumber>;
+        maxQueuedQueries: z.ZodDefault<z.ZodNumber>;
+        queueTimeoutMs: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         maxRows: number;
         maxColumns: number;
         maxStatementMs: number;
         maxFieldChars: number;
+        maxResultBytes: number;
+        maxBlobBytes: number;
+        maxConcurrentQueries: number;
+        maxQueuedQueries: number;
+        queueTimeoutMs: number;
     }, {
         maxRows?: number | undefined;
         maxColumns?: number | undefined;
         maxStatementMs?: number | undefined;
         maxFieldChars?: number | undefined;
+        maxResultBytes?: number | undefined;
+        maxBlobBytes?: number | undefined;
+        maxConcurrentQueries?: number | undefined;
+        maxQueuedQueries?: number | undefined;
+        queueTimeoutMs?: number | undefined;
     }>>;
     audit: z.ZodDefault<z.ZodObject<{
         logPath: z.ZodDefault<z.ZodString>;
         includeRawSql: z.ZodDefault<z.ZodBoolean>;
+        maxBytes: z.ZodDefault<z.ZodNumber>;
+        maxFiles: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         logPath: string;
         includeRawSql: boolean;
+        maxBytes: number;
+        maxFiles: number;
     }, {
         logPath?: string | undefined;
         includeRawSql?: boolean | undefined;
+        maxBytes?: number | undefined;
+        maxFiles?: number | undefined;
+    }>>;
+    security: z.ZodDefault<z.ZodObject<{
+        mutationsEnabled: z.ZodDefault<z.ZodBoolean>;
+        dynamicTargetsEnabled: z.ZodDefault<z.ZodBoolean>;
+        requireTls: z.ZodDefault<z.ZodBoolean>;
+        approvalSecretPath: z.ZodOptional<z.ZodString>;
+        approvalTtlSeconds: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        mutationsEnabled: boolean;
+        dynamicTargetsEnabled: boolean;
+        requireTls: boolean;
+        approvalTtlSeconds: number;
+        approvalSecretPath?: string | undefined;
+    }, {
+        mutationsEnabled?: boolean | undefined;
+        dynamicTargetsEnabled?: boolean | undefined;
+        requireTls?: boolean | undefined;
+        approvalSecretPath?: string | undefined;
+        approvalTtlSeconds?: number | undefined;
     }>>;
     slowSqlSource: z.ZodDefault<z.ZodObject<{
         taurusApi: z.ZodDefault<z.ZodObject<{
@@ -305,10 +345,24 @@ export declare const ConfigSchema: z.ZodObject<{
         maxColumns: number;
         maxStatementMs: number;
         maxFieldChars: number;
+        maxResultBytes: number;
+        maxBlobBytes: number;
+        maxConcurrentQueries: number;
+        maxQueuedQueries: number;
+        queueTimeoutMs: number;
     };
     audit: {
         logPath: string;
         includeRawSql: boolean;
+        maxBytes: number;
+        maxFiles: number;
+    };
+    security: {
+        mutationsEnabled: boolean;
+        dynamicTargetsEnabled: boolean;
+        requireTls: boolean;
+        approvalTtlSeconds: number;
+        approvalSecretPath?: string | undefined;
     };
     slowSqlSource: {
         taurusApi: {
@@ -382,10 +436,24 @@ export declare const ConfigSchema: z.ZodObject<{
         maxColumns?: number | undefined;
         maxStatementMs?: number | undefined;
         maxFieldChars?: number | undefined;
+        maxResultBytes?: number | undefined;
+        maxBlobBytes?: number | undefined;
+        maxConcurrentQueries?: number | undefined;
+        maxQueuedQueries?: number | undefined;
+        queueTimeoutMs?: number | undefined;
     } | undefined;
     audit?: {
         logPath?: string | undefined;
         includeRawSql?: boolean | undefined;
+        maxBytes?: number | undefined;
+        maxFiles?: number | undefined;
+    } | undefined;
+    security?: {
+        mutationsEnabled?: boolean | undefined;
+        dynamicTargetsEnabled?: boolean | undefined;
+        requireTls?: boolean | undefined;
+        approvalSecretPath?: string | undefined;
+        approvalTtlSeconds?: number | undefined;
     } | undefined;
     slowSqlSource?: {
         taurusApi?: {

package/dist/config/schema.js

@@ -5,12 +5,28 @@ const LimitsSchema = z
     maxColumns: z.number().int().positive().default(50),
     maxStatementMs: z.number().int().positive().default(15000),
     maxFieldChars: z.number().int().positive().default(2048),
+    maxResultBytes: z.number().int().positive().default(1048576),
+    maxBlobBytes: z.number().int().positive().default(65536),
+    maxConcurrentQueries: z.number().int().positive().default(8),
+    maxQueuedQueries: z.number().int().nonnegative().default(32),
+    queueTimeoutMs: z.number().int().positive().default(5000),
 })
     .default({});
 const AuditSchema = z
     .object({
     logPath: z.string().min(1).default("~/.taurusdb-mcp/audit.jsonl"),
     includeRawSql: z.boolean().default(false),
+    maxBytes: z.number().int().positive().default(104857600),
+    maxFiles: z.number().int().positive().max(100).default(10),
+})
+    .default({});
+const SecuritySchema = z
+    .object({
+    mutationsEnabled: z.boolean().default(false),
+    dynamicTargetsEnabled: z.boolean().default(false),
+    requireTls: z.boolean().default(true),
+    approvalSecretPath: z.string().min(1).optional(),
+    approvalTtlSeconds: z.number().int().positive().max(3600).default(300),
 })
     .default({});
 const CloudSchema = z
@@ -89,6 +105,7 @@ export const ConfigSchema = z.object({
     cloud: CloudSchema,
     limits: LimitsSchema,
     audit: AuditSchema,
+    security: SecuritySchema,
     slowSqlSource: z
         .object({
         taurusApi: TaurusApiSlowSqlSourceSchema,

package/dist/context/datasource-resolver.js

@@ -41,12 +41,19 @@ export class DefaultDatasourceResolver {
             engine: profile.engine,
             database: normalizeString(input.database) ?? profile.database,
             schema: normalizeString(input.schema),
+            host: profile.host,
+            port: profile.port,
+            projectId: this.config.cloud.projectId,
+            instanceId: profile.instanceId ?? this.config.cloud.instanceId,
+            nodeId: profile.nodeId ?? this.config.cloud.nodeId,
             limits: {
                 readonly: input.readonly ?? true,
                 timeoutMs: resolveTimeoutMs(input.timeout_ms, this.config.limits.maxStatementMs),
                 maxRows: this.config.limits.maxRows,
                 maxColumns: this.config.limits.maxColumns,
                 maxFieldChars: this.config.limits.maxFieldChars,
+                maxResultBytes: this.config.limits.maxResultBytes,
+                maxBlobBytes: this.config.limits.maxBlobBytes,
             },
         };
     }

package/dist/context/session-context.d.ts

@@ -5,6 +5,8 @@ export interface RuntimeLimits {
     maxRows: number;
     maxColumns: number;
     maxFieldChars: number;
+    maxResultBytes?: number;
+    maxBlobBytes?: number;
 }
 export interface SessionContext {
     task_id: string;
@@ -12,6 +14,11 @@ export interface SessionContext {
     engine: DatabaseEngine;
     database?: string;
     schema?: string;
+    host?: string;
+    port?: number;
+    projectId?: string;
+    instanceId?: string;
+    nodeId?: string;
     limits: RuntimeLimits;
 }
 export interface DatasourceResolveInput {

package/dist/diagnostics/replication-lag.d.ts

@@ -0,0 +1,4 @@
+import type { SessionContext } from "../context/session-context.js";
+import type { SqlExecutor } from "../executor/sql-executor.js";
+import type { DiagnoseReplicationLagInput, DiagnosticResult } from "./types.js";
+export declare function diagnoseReplicationLag(executor: SqlExecutor, input: DiagnoseReplicationLagInput, ctx: SessionContext): Promise<DiagnosticResult>;