taurusdb-core 0.4.0 → 0.5.0-rc.1

package/dist/safety/redaction.js

@@ -2,6 +2,8 @@ import { createHash } from "node:crypto";
 const DEFAULT_MAX_ROWS = 200;
 const DEFAULT_MAX_COLUMNS = 50;
 const DEFAULT_MAX_FIELD_CHARS = 2048;
+const DEFAULT_MAX_RESULT_BYTES = 1048576;
+const DEFAULT_MAX_BLOB_BYTES = 65536;
 const DEFAULT_SENSITIVE_STRATEGY = "mask";
 const SENSITIVE_COLUMN_PATTERNS = [
     /password|passwd|secret/i,
@@ -58,6 +60,14 @@ function isSensitiveColumn(name, explicitSensitive) {
     const base = candidates[candidates.length - 1];
     return SENSITIVE_COLUMN_PATTERNS.some((pattern) => pattern.test(base));
 }
+export function hasSensitiveColumnReference(columns) {
+    for (const column of columns) {
+        if (isSensitiveColumn(column, new Set())) {
+            return true;
+        }
+    }
+    return false;
+}
 function maskValue(columnName, value) {
     if (value === null || value === undefined) {
         return value;
@@ -87,7 +97,19 @@ function hashValue(value) {
     const digest = createHash("sha256").update(plain).digest("hex").slice(0, 12);
     return `[HASH:${digest}]`;
 }
-function truncateFieldValue(value, maxFieldChars) {
+function truncateFieldValue(value, maxFieldChars, maxBlobBytes) {
+    if (Buffer.isBuffer(value)) {
+        if (value.byteLength > maxBlobBytes) {
+            return {
+                value: `[BINARY:${value.byteLength} bytes; omitted by max_blob_bytes]`,
+                truncated: true,
+            };
+        }
+        return {
+            value: `[BINARY:${value.byteLength} bytes;base64:${value.toString("base64")}]`,
+            truncated: false,
+        };
+    }
     if (typeof value !== "string") {
         return { value, truncated: false };
     }
@@ -104,12 +126,14 @@ class DefaultResultRedactor {
         const maxRows = asPositiveInt(policy.maxRows, DEFAULT_MAX_ROWS);
         const maxColumns = asPositiveInt(policy.maxColumns, DEFAULT_MAX_COLUMNS);
         const maxFieldChars = asPositiveInt(policy.maxFieldChars, DEFAULT_MAX_FIELD_CHARS);
+        const maxResultBytes = asPositiveInt(policy.maxResultBytes, DEFAULT_MAX_RESULT_BYTES);
+        const maxBlobBytes = asPositiveInt(policy.maxBlobBytes, DEFAULT_MAX_BLOB_BYTES);
         const sensitiveStrategy = policy.sensitiveStrategy ?? DEFAULT_SENSITIVE_STRATEGY;
         const explicitSensitive = buildSensitiveSet(policy.sensitiveColumns);
         const sourceColumns = Array.isArray(raw.columns) ? raw.columns : [];
         const sourceRows = Array.isArray(raw.rows) ? raw.rows : [];
         const originalRowCount = asNonNegativeInt(raw.rowCount, sourceRows.length);
-        const rowTruncated = sourceRows.length > maxRows || originalRowCount > maxRows;
+        let rowTruncated = sourceRows.length > maxRows || originalRowCount > maxRows;
         const columnTruncated = sourceColumns.length > maxColumns;
         const rowLimited = sourceRows.slice(0, maxRows);
         const columnLimited = sourceColumns.slice(0, maxColumns);
@@ -120,7 +144,8 @@ class DefaultResultRedactor {
         const droppedColumns = [];
         for (let index = 0; index < columnLimited.length; index += 1) {
             const column = columnLimited[index];
-            const sensitive = isSensitiveColumn(column.name, explicitSensitive);
+            const sensitive = policy.maskAllColumns === true ||
+                isSensitiveColumn(column.name, explicitSensitive);
             if (sensitive && sensitiveStrategy === "drop") {
                 droppedColumns.push(column.name);
                 continue;
@@ -151,7 +176,7 @@ class DefaultResultRedactor {
                     }
                 }
                 else {
-                    const truncated = truncateFieldValue(rawValue, maxFieldChars);
+                    const truncated = truncateFieldValue(rawValue, maxFieldChars, maxBlobBytes);
                     value = truncated.value;
                     if (truncated.truncated) {
                         truncatedColumns.add(column.name);
@@ -162,15 +187,31 @@ class DefaultResultRedactor {
             return outputRow;
         });
         const fieldTruncated = truncatedColumns.size > 0;
+        let returnedBytes = Buffer.byteLength(JSON.stringify({ columns: keepColumns, rows: [] }), "utf8");
+        let byteTruncated = false;
+        const byteLimitedRows = [];
+        for (const row of outputRows) {
+            const rowBytes = Buffer.byteLength(JSON.stringify(row), "utf8");
+            const delimiterBytes = byteLimitedRows.length > 0 ? 1 : 0;
+            if (returnedBytes + delimiterBytes + rowBytes > maxResultBytes) {
+                byteTruncated = true;
+                rowTruncated = true;
+                break;
+            }
+            byteLimitedRows.push(row);
+            returnedBytes += delimiterBytes + rowBytes;
+        }
         return {
             columns: keepColumns,
-            rows: outputRows,
+            rows: byteLimitedRows,
             rowCount: originalRowCount,
             originalRowCount,
-            truncated: rowTruncated || columnTruncated || fieldTruncated,
+            truncated: rowTruncated || columnTruncated || fieldTruncated || byteTruncated,
             rowTruncated,
             columnTruncated,
             fieldTruncated,
+            byteTruncated,
+            returnedBytes,
             redactedColumns: keepColumns
                 .map((column) => column.name)
                 .filter((name) => redactedColumns.has(name)),

package/dist/safety/sql-classifier.d.ts

@@ -8,6 +8,7 @@ export interface SqlClassification {
     sqlHash: string;
     isMultiStatement: boolean;
     referencedTables: string[];
+    referencedSchemas: string[];
     referencedColumns: string[];
     hasWhere: boolean;
     hasLimit: boolean;

package/dist/safety/sql-classifier.js

@@ -32,6 +32,7 @@ export function classifySql(ast, normalized, engine) {
         sqlHash: normalized.sqlHash,
         isMultiStatement: ast.isMultiStatement,
         referencedTables: extractTables(ast),
+        referencedSchemas: dedupeCaseInsensitive(ast.tables.flatMap((table) => (table.schema ? [table.schema] : []))),
         referencedColumns: extractColumns(ast),
         hasWhere: ast.where !== undefined,
         hasLimit: ast.limit !== undefined,

package/dist/safety/sql-validator.d.ts

@@ -16,4 +16,5 @@ export interface ExplainRiskSummary {
     riskHints: string[];
 }
 export declare function validateToolScope(toolName: string, cls: SqlClassification): ValidationResult;
+export declare function validateDatabaseScope(cls: SqlClassification, database: string | undefined): ValidationResult;
 export declare function validateStaticRules(cls: SqlClassification): ValidationResult;

package/dist/safety/sql-validator.js

@@ -1,6 +1,7 @@
 const READONLY_STATEMENTS = new Set(["select", "show", "explain", "describe"]);
 const MUTATION_STATEMENTS = new Set(["insert", "update", "delete"]);
 const STAR_COLUMN_PATTERN = /(^|\.)(\*|\(\.\*\))$/;
+const READONLY_SIDE_EFFECT_PATTERN = /\b(?:INTO\s+(?:OUTFILE|DUMPFILE)|FOR\s+UPDATE|LOCK\s+IN\s+SHARE\s+MODE|GET_LOCK\s*\(|RELEASE_LOCK\s*\(|SLEEP\s*\(|BENCHMARK\s*\(|LOAD_FILE\s*\()/i;
 function allow(riskLevel = "low") {
     return {
         action: "allow",
@@ -75,6 +76,23 @@ export function validateToolScope(toolName, cls) {
     }
     return allow("low");
 }
+export function validateDatabaseScope(cls, database) {
+    const schemas = cls.referencedSchemas ?? [];
+    if (schemas.length === 0) {
+        return allow("low");
+    }
+    if (!database) {
+        return block(["D001"], ["SQL uses an explicit database but the session has no bound database."]);
+    }
+    const expected = database.toLowerCase();
+    const outOfScope = schemas.filter((schema) => schema.toLowerCase() !== expected);
+    if (outOfScope.length > 0) {
+        return block(["D002"], [
+            `SQL references database(s) outside the bound database "${database}": ${outOfScope.join(", ")}.`,
+        ]);
+    }
+    return allow("low");
+}
 export function validateStaticRules(cls) {
     const reasonCodes = [];
     const riskHints = [];
@@ -117,7 +135,13 @@ export function validateStaticRules(cls) {
             escalateToConfirm("R006", "Mutation SQL with WHERE requires confirmation.");
         }
     }
+    if (cls.statementType === "insert") {
+        escalateToConfirm("R006", "INSERT, REPLACE, and UPSERT statements require confirmation.");
+    }
     if (cls.statementType === "select") {
+        if (READONLY_SIDE_EFFECT_PATTERN.test(cls.normalizedSql)) {
+            escalateToBlock("R009", "SELECT statements with side effects or blocking functions are blocked.");
+        }
         if (!cls.hasLimit && !cls.hasAggregate) {
             escalateToMediumAllow("R007", "Detail SELECT without LIMIT has medium risk.");
         }

package/dist/schema/adapters/mysql.js

@@ -272,7 +272,9 @@ export class MySqlSchemaAdapter {
         }));
     }
     async queryObjects(ctx, sql) {
-        const session = await this.connectionPool.acquire(ctx.datasource, "ro");
+        const session = await this.connectionPool.acquire(ctx.datasource, "ro", {
+            database: ctx.database,
+        });
         try {
             const result = await session.execute(sql, { timeoutMs: ctx.limits.timeoutMs });
             return rowsToObjects(result);

package/dist/taurus/flashback.js

@@ -1,6 +1,6 @@
 import { createSqlParser } from "../safety/parser/index.js";
 import { normalizeSql } from "../utils/hash.js";
-const IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_$]*$/;
+import { quoteMysqlIdentifier } from "../utils/mysql-identifier.js";
 const SQL_TIMESTAMP_PATTERN = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})(?:\.\d{1,6})?$/;
 const RELATIVE_DURATION_PATTERN = /(\d+)\s*(ms|milliseconds?|s|sec|secs|seconds?|m|min|mins|minutes?|h|hr|hrs|hours?|d|days?)/gi;
 const UNIT_TO_MS = {
@@ -26,12 +26,6 @@ function normalizeDurationUnit(unit) {
     }
     return "d";
 }
-function quoteIdentifier(identifier, fieldName) {
-    if (!IDENTIFIER_PATTERN.test(identifier)) {
-        throw new Error(`Invalid ${fieldName}: "${identifier}".`);
-    }
-    return `\`${identifier}\``;
-}
 export function normalizeFlashbackWhereClause(where) {
     const parser = createSqlParser("mysql");
     const candidate = parser.normalize(`SELECT 1 FROM placeholder WHERE (${where})`);
@@ -128,10 +122,10 @@ export function resolveFlashbackTimestamp(asOf, now = Date.now) {
     throw new Error("Flashback query requires either as_of.timestamp or as_of.relative.");
 }
 export function buildFlashbackSql(input, defaultDatabase, now = Date.now) {
-    const database = quoteIdentifier(input.database ?? defaultDatabase, "database");
-    const table = quoteIdentifier(input.table, "table");
+    const database = quoteMysqlIdentifier(input.database ?? defaultDatabase, "database");
+    const table = quoteMysqlIdentifier(input.table, "table");
     const columns = input.columns && input.columns.length > 0
-        ? input.columns.map((column) => quoteIdentifier(column, "column")).join(", ")
+        ? input.columns.map((column) => quoteMysqlIdentifier(column, "column")).join(", ")
         : "*";
     const timestamp = resolveFlashbackTimestamp(input.asOf, now);
     const clauses = [

package/dist/taurus/recycle-bin.js

@@ -1,12 +1,6 @@
+import { quoteMysqlIdentifier } from "../utils/mysql-identifier.js";
 export const RECYCLE_BIN_DATABASE = "__recyclebin__";
-const SIMPLE_IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_$]*$/;
 const RECYCLE_TABLE_PATTERN = /^[A-Za-z0-9_$@.-]+$/;
-function quoteIdentifier(identifier, fieldName) {
-    if (!SIMPLE_IDENTIFIER_PATTERN.test(identifier)) {
-        throw new Error(`Invalid ${fieldName}: "${identifier}".`);
-    }
-    return `\`${identifier}\``;
-}
 function quoteRecycleTableName(table) {
     if (!RECYCLE_TABLE_PATTERN.test(table)) {
         throw new Error(`Invalid recycle_table: "${table}".`);
@@ -45,7 +39,7 @@ export function buildRestoreRecycleBinTableSql(input) {
         if (!input.destinationDatabase || !input.destinationTable) {
             throw new Error("insert_select restore requires destination_database and destination_table. Create the destination table with a compatible structure before calling this tool.");
         }
-        return `INSERT INTO ${quoteIdentifier(input.destinationDatabase, "destination_database")}.${quoteIdentifier(input.destinationTable, "destination_table")} SELECT * FROM \`${RECYCLE_BIN_DATABASE}\`.${quoteRecycleTableName(input.recycleTable)}`;
+        return `INSERT INTO ${quoteMysqlIdentifier(input.destinationDatabase, "destination_database")}.${quoteMysqlIdentifier(input.destinationTable, "destination_table")} SELECT * FROM \`${RECYCLE_BIN_DATABASE}\`.${quoteRecycleTableName(input.recycleTable)}`;
     }
     throw new Error(`Unsupported restore method: ${method}.`);
 }

package/dist/utils/formatter.d.ts

@@ -11,6 +11,8 @@ export declare const ErrorCode: {
     readonly QUERY_CANCELLED: "QUERY_CANCELLED";
     readonly CONNECTION_FAILED: "CONNECTION_FAILED";
     readonly RESULT_TOO_LARGE: "RESULT_TOO_LARGE";
+    readonly AUDIT_FAILED: "AUDIT_FAILED";
+    readonly SERVER_BUSY: "SERVER_BUSY";
     readonly UNSUPPORTED_FEATURE: "UNSUPPORTED_FEATURE";
 };
 export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
@@ -53,7 +55,8 @@ export type FormatBlockedOptions = {
     details?: Record<string, unknown>;
 };
 export type FormatConfirmationRequiredOptions = {
-    confirmationToken: string;
+    approvalRequest: string;
+    requestId: string;
     metadata: ResponseMetadata;
     summary?: string;
     message?: string;
@@ -64,7 +67,8 @@ export declare function formatSuccess<T>(data: T, options: FormatSuccessOptions)
 export declare function formatError<T = unknown>(options: FormatErrorOptions<T>): ToolResponse<T>;
 export declare function formatBlocked(options: FormatBlockedOptions): ToolResponse;
 export declare function formatConfirmationRequired(options: FormatConfirmationRequiredOptions): ToolResponse<{
-    confirmation_token: string;
+    approval_request: string;
+    request_id: string;
     risk_level?: string;
     sql_hash?: string;
 }>;

package/dist/utils/formatter.js

@@ -10,6 +10,8 @@ export const ErrorCode = {
     QUERY_CANCELLED: "QUERY_CANCELLED",
     CONNECTION_FAILED: "CONNECTION_FAILED",
     RESULT_TOO_LARGE: "RESULT_TOO_LARGE",
+    AUDIT_FAILED: "AUDIT_FAILED",
+    SERVER_BUSY: "SERVER_BUSY",
     UNSUPPORTED_FEATURE: "UNSUPPORTED_FEATURE",
 };
 export function formatSuccess(data, options) {
@@ -47,12 +49,14 @@ export function formatBlocked(options) {
 export function formatConfirmationRequired(options) {
     return formatError({
         code: ErrorCode.CONFIRMATION_REQUIRED,
-        message: options.message ?? "Re-run the same SQL with confirmation_token to continue.",
-        summary: options.summary ?? "This SQL will modify data and requires explicit confirmation.",
+        message: options.message ??
+            "An external operator must sign approval_request with `taurusdb-mcp approve` before retrying with approval_token.",
+        summary: options.summary ?? "This SQL will modify data and requires external human approval.",
         retryable: true,
         metadata: options.metadata,
         data: {
-            confirmation_token: options.confirmationToken,
+            approval_request: options.approvalRequest,
+            request_id: options.requestId,
             risk_level: options.riskLevel,
             sql_hash: options.sqlHash,
         },

package/dist/utils/logger.js

@@ -8,6 +8,14 @@ const REDACT_PATHS = [
     "secret",
     "token",
     "*.token",
+    "approval_token",
+    "*.approval_token",
+    "approval_request",
+    "*.approval_request",
+    "authorization",
+    "*.authorization",
+    "headers.authorization",
+    "*.headers.authorization",
     "accessKeyId",
     "*.accessKeyId",
     "secretAccessKey",

package/dist/utils/mysql-identifier.d.ts

@@ -0,0 +1 @@
+export declare function quoteMysqlIdentifier(identifier: string, fieldName?: string): string;

package/dist/utils/mysql-identifier.js

@@ -0,0 +1,9 @@
+export function quoteMysqlIdentifier(identifier, fieldName = "identifier") {
+    if (identifier.length === 0) {
+        throw new Error(`Invalid ${fieldName}: value cannot be empty.`);
+    }
+    if (identifier.includes("\0")) {
+        throw new Error(`Invalid ${fieldName}: NUL bytes are not allowed.`);
+    }
+    return `\`${identifier.replace(/`/g, "``")}\``;
+}

package/package.json

@@ -1,7 +1,17 @@
 {
   "name": "taurusdb-core",
-  "version": "0.4.0",
+  "version": "0.5.0-rc.1",
   "description": "Shared TaurusDB data-plane engine for schema, SQL execution, guardrails, and diagnostics.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/youweichen0208/taurus-mcp-server.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/youweichen0208/taurus-mcp-server#readme",
+  "bugs": {
+    "url": "https://github.com/youweichen0208/taurus-mcp-server/issues"
+  },
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,7 +26,8 @@
     "guardrails"
   ],
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "files": [
     "dist"