taurusdb-core 0.3.0 → 0.5.0-rc.1

package/dist/executor/concurrency-limiter.js

@@ -0,0 +1,67 @@
+export class QueryConcurrencyError extends Error {
+    code = "SERVER_BUSY";
+    constructor(message) {
+        super(message);
+        this.name = "QueryConcurrencyError";
+    }
+}
+export class QueryConcurrencyLimiter {
+    maxConcurrent;
+    maxQueued;
+    queueTimeoutMs;
+    active = 0;
+    queue = [];
+    constructor(maxConcurrent, maxQueued, queueTimeoutMs) {
+        this.maxConcurrent = maxConcurrent;
+        this.maxQueued = maxQueued;
+        this.queueTimeoutMs = queueTimeoutMs;
+    }
+    async run(operation) {
+        const release = await this.acquire();
+        try {
+            return await operation();
+        }
+        finally {
+            release();
+        }
+    }
+    acquire() {
+        if (this.active < this.maxConcurrent) {
+            this.active += 1;
+            return Promise.resolve(this.releaseFactory());
+        }
+        if (this.queue.length >= this.maxQueued) {
+            return Promise.reject(new QueryConcurrencyError("Query concurrency queue is full."));
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                resolve,
+                reject,
+                timer: setTimeout(() => {
+                    const index = this.queue.indexOf(waiter);
+                    if (index >= 0) {
+                        this.queue.splice(index, 1);
+                    }
+                    reject(new QueryConcurrencyError("Timed out waiting for query capacity."));
+                }, this.queueTimeoutMs),
+            };
+            this.queue.push(waiter);
+        });
+    }
+    releaseFactory() {
+        let released = false;
+        return () => {
+            if (released) {
+                return;
+            }
+            released = true;
+            const waiter = this.queue.shift();
+            if (waiter) {
+                clearTimeout(waiter.timer);
+                waiter.resolve(this.releaseFactory());
+                return;
+            }
+            this.active -= 1;
+        };
+    }
+}

package/dist/executor/connection-pool.d.ts

@@ -18,6 +18,7 @@ export interface RawResult {
 export interface Session {
     id: string;
     datasource: string;
+    database?: string;
     mode: PoolMode;
     execute(sql: string, options?: ExecOptions): Promise<RawResult>;
     cancel(): Promise<void>;
@@ -35,7 +36,7 @@ export interface PoolHealth {
 }
 export interface ConnectionPool {
     acquire(datasource: string, mode: PoolMode, opts?: {
-        allowReadonlyFallbackForMutations?: boolean;
+        database?: string;
     }): Promise<Session>;
     release(session: Session): Promise<void>;
     healthCheck(datasource: string): Promise<PoolHealth>;
@@ -91,7 +92,7 @@ export declare class ConnectionPoolManager implements ConnectionPool {
     private readonly activeSessions;
     constructor(options: ConnectionPoolManagerOptions);
     acquire(datasource: string, mode: PoolMode, opts?: {
-        allowReadonlyFallbackForMutations?: boolean;
+        database?: string;
     }): Promise<Session>;
     release(session: Session): Promise<void>;
     healthCheck(datasource: string): Promise<PoolHealth>;

package/dist/executor/connection-pool.js

@@ -1,3 +1,4 @@
+import { isIP } from "node:net";
 import { ulid } from "ulid";
 export class ConnectionPoolError extends Error {
     code = "CONNECTION_FAILED";
@@ -9,35 +10,42 @@ export class ConnectionPoolError extends Error {
         }
     }
 }
-function poolKey(datasource, mode) {
-    return `${datasource}:${mode}`;
+function poolKey(datasource, mode, database) {
+    return JSON.stringify([datasource, mode, database ?? null]);
 }
-async function resolveTls(tls, secretResolver) {
-    if (!tls) {
+async function resolveTls(tls, secretResolver, host, requireTls) {
+    if (!tls && !requireTls) {
         return undefined;
     }
+    if (requireTls && tls?.enabled === false) {
+        throw new ConnectionPoolError("TLS is required by server policy and cannot be disabled for this datasource.");
+    }
+    if (requireTls && tls?.rejectUnauthorized === false) {
+        throw new ConnectionPoolError("TLS certificate verification is required by server policy.");
+    }
     const resolved = {
-        enabled: tls.enabled,
-        rejectUnauthorized: tls.rejectUnauthorized,
-        servername: tls.servername,
+        enabled: tls?.enabled ?? true,
+        rejectUnauthorized: tls?.rejectUnauthorized ?? true,
+        servername: tls?.servername ?? (isIP(host) === 0 ? host : undefined),
     };
-    if (tls.ca) {
+    if (tls?.ca) {
         resolved.ca = await secretResolver.resolve(tls.ca);
     }
-    if (tls.cert) {
+    if (tls?.cert) {
         resolved.cert = await secretResolver.resolve(tls.cert);
     }
-    if (tls.key) {
+    if (tls?.key) {
         resolved.key = await secretResolver.resolve(tls.key);
     }
     return resolved;
 }
-function selectCredential(profile, mode, _opts = {}) {
-    void mode;
-    if (!profile.user) {
-        throw new ConnectionPoolError(`Datasource "${profile.name}" does not define SQL credentials. Call begin_sql_login and complete the secure local login form before executing SQL.`);
+function selectCredential(profile, mode) {
+    const credential = mode === "rw" ? profile.mutationUser : profile.user;
+    if (!credential) {
+        const credentialKind = mode === "rw" ? "mutation" : "read-only";
+        throw new ConnectionPoolError(`Datasource "${profile.name}" does not define ${credentialKind} SQL credentials. Configure a dedicated ${credentialKind} database username and password reference.`);
     }
-    return profile.user;
+    return credential;
 }
 async function resolveCredentialValue(ref, secretResolver, context) {
     try {
@@ -65,7 +73,8 @@ export class ConnectionPoolManager {
         if (!profile) {
             throw new ConnectionPoolError(`Datasource profile not found: "${datasource}".`);
         }
-        const entry = await this.getOrCreatePool(profile, mode, opts);
+        const database = opts.database ?? profile.database;
+        const entry = await this.getOrCreatePool(profile, mode, database);
         let driverSession;
         try {
             driverSession = await entry.pool.acquire();
@@ -79,6 +88,7 @@ export class ConnectionPoolManager {
             entryKey: entry.key,
             driverSession,
             datasource,
+            database,
             mode,
         };
         this.activeSessions.set(sessionId, active);
@@ -86,6 +96,7 @@ export class ConnectionPoolManager {
         return {
             id: sessionId,
             datasource,
+            database,
             mode,
             async execute(sql, options) {
                 return active.driverSession.execute(sql, options);
@@ -151,13 +162,13 @@ export class ConnectionPoolManager {
             };
         }
     }
-    async getOrCreatePool(profile, mode, opts = {}) {
-        const key = poolKey(profile.name, mode);
+    async getOrCreatePool(profile, mode, database) {
+        const key = poolKey(profile.name, mode, database);
         const existing = this.pools.get(key);
         if (existing) {
             return existing instanceof Promise ? existing : existing;
         }
-        const pending = this.createPool(profile, mode, opts)
+        const pending = this.createPool(profile, mode, database)
             .then((entry) => {
             this.pools.set(key, entry);
             return entry;
@@ -169,7 +180,7 @@ export class ConnectionPoolManager {
         this.pools.set(key, pending);
         return pending;
     }
-    async createPool(profile, mode, opts = {}) {
+    async createPool(profile, mode, database) {
         const adapter = this.adapters[profile.engine];
         if (!adapter) {
             throw new ConnectionPoolError(`No driver adapter registered for engine "${profile.engine}".`);
@@ -177,9 +188,9 @@ export class ConnectionPoolManager {
         if (!profile.host) {
             throw new ConnectionPoolError(`Datasource "${profile.name}" does not define a host. Select a cloud instance or configure host in the datasource profile.`);
         }
-        const credential = selectCredential(profile, mode, opts);
+        const credential = selectCredential(profile, mode);
         const password = await resolveCredentialValue(credential.password, this.secretResolver, `${profile.name}.${mode}.password`);
-        const tls = await resolveTls(profile.tls, this.secretResolver);
+        const tls = await resolveTls(profile.tls, this.secretResolver, profile.host, this.config.security.requireTls);
         let pool;
         try {
             pool = await adapter.createPool({
@@ -188,7 +199,7 @@ export class ConnectionPoolManager {
                 engine: profile.engine,
                 host: profile.host,
                 port: profile.port,
-                database: profile.database,
+                database,
                 username: credential.username,
                 password,
                 poolSize: profile.poolSize,
@@ -199,8 +210,9 @@ export class ConnectionPoolManager {
             throw new ConnectionPoolError(`Failed to create ${mode === "ro" ? "readonly" : "mutation"} pool for datasource "${profile.name}".`, error);
         }
         return {
-            key: poolKey(profile.name, mode),
+            key: poolKey(profile.name, mode, database),
             datasource: profile.name,
+            database,
             mode,
             pool,
         };

package/dist/executor/sql-executor.d.ts

@@ -11,6 +11,9 @@ export type SqlExecutorOptions = {
     historyLimit?: number;
     queryTracker?: QueryTracker;
     resultRedactor?: ResultRedactor;
+    maxConcurrentQueries?: number;
+    maxQueuedQueries?: number;
+    queueTimeoutMs?: number;
 };
 export declare class SqlExecutorImpl implements SqlExecutor {
     private readonly connectionPool;

package/dist/executor/sql-executor.js

@@ -3,6 +3,22 @@ import { buildExplainRecommendations, normalizeExplainRows, summarizeExplainRows
 import { createQueryTracker, } from "./query-tracker.js";
 import { createResultRedactor, } from "../safety/redaction.js";
 import { asFiniteNumber, inferColumns, normalizeRows } from "./result-normalizer.js";
+import { QueryConcurrencyLimiter } from "./concurrency-limiter.js";
+import { buildServerBoundedReadonlySql } from "./bounded-sql.js";
+function isTimeoutError(error) {
+    return /timeout|timed out/i.test(error instanceof Error ? error.message : String(error));
+}
+async function cancelTimedOutSession(session, error) {
+    if (!isTimeoutError(error)) {
+        return;
+    }
+    try {
+        await session.cancel();
+    }
+    catch {
+        // Keep the original timeout error.
+    }
+}
 export class SqlExecutorImpl {
     connectionPool;
     now;
@@ -25,7 +41,9 @@ export class SqlExecutorImpl {
     async explain(sql, ctx) {
         const queryId = this.queryIdGenerator();
         const startedAt = this.now();
-        const session = await this.connectionPool.acquire(ctx.datasource, "ro");
+        const session = await this.connectionPool.acquire(ctx.datasource, "ro", {
+            database: ctx.database,
+        });
         const active = this.beginQuery(queryId, session, ctx, "ro", startedAt);
         try {
             const result = await session.execute(`EXPLAIN ${sql}`, {
@@ -45,6 +63,7 @@ export class SqlExecutorImpl {
             };
         }
         catch (error) {
+            await cancelTimedOutSession(session, error);
             const durationMs = this.now() - startedAt;
             this.completeQuery(active.queryId, active.cancelRequested ? "cancelled" : "failed", durationMs, error);
             throw error;
@@ -59,11 +78,16 @@ export class SqlExecutorImpl {
         const maxRows = opts.maxRows ?? ctx.limits.maxRows;
         const maxColumns = opts.maxColumns ?? ctx.limits.maxColumns;
         const maxFieldChars = opts.maxFieldChars ?? ctx.limits.maxFieldChars ?? 2048;
+        const maxResultBytes = opts.maxResultBytes ?? ctx.limits.maxResultBytes ?? 1048576;
+        const maxBlobBytes = opts.maxBlobBytes ?? ctx.limits.maxBlobBytes ?? 65536;
         const timeoutMs = opts.timeoutMs ?? ctx.limits.timeoutMs;
-        const session = await this.connectionPool.acquire(ctx.datasource, "ro");
+        const session = await this.connectionPool.acquire(ctx.datasource, "ro", {
+            database: ctx.database,
+        });
         const active = this.beginQuery(queryId, session, ctx, "ro", startedAt);
         try {
-            const result = await session.execute(sql, { timeoutMs });
+            const executionSql = buildServerBoundedReadonlySql(sql, maxRows);
+            const result = await session.execute(executionSql, { timeoutMs });
             const sourceRows = Array.isArray(result.rows) ? result.rows : [];
             const columns = inferColumns(result, sourceRows);
             const normalizedRows = normalizeRows(sourceRows, columns);
@@ -76,6 +100,9 @@ export class SqlExecutorImpl {
                 maxRows,
                 maxColumns,
                 maxFieldChars,
+                maxResultBytes,
+                maxBlobBytes,
+                maskAllColumns: opts.maskAllColumns,
                 sensitiveColumns: opts.sensitiveColumns,
                 sensitiveStrategy: opts.sensitiveStrategy,
             });
@@ -91,6 +118,8 @@ export class SqlExecutorImpl {
                 rowTruncated: redacted.rowTruncated,
                 columnTruncated: redacted.columnTruncated,
                 fieldTruncated: redacted.fieldTruncated,
+                byteTruncated: redacted.byteTruncated,
+                returnedBytes: redacted.returnedBytes,
                 redactedColumns: redacted.redactedColumns,
                 droppedColumns: redacted.droppedColumns,
                 truncatedColumns: redacted.truncatedColumns,
@@ -98,6 +127,7 @@ export class SqlExecutorImpl {
             };
         }
         catch (error) {
+            await cancelTimedOutSession(session, error);
             const durationMs = this.now() - startedAt;
             this.completeQuery(active.queryId, active.cancelRequested ? "cancelled" : "failed", durationMs, error);
             throw error;
@@ -114,7 +144,7 @@ export class SqlExecutorImpl {
         const startedAt = this.now();
         const timeoutMs = opts.timeoutMs ?? ctx.limits.timeoutMs;
         const session = await this.connectionPool.acquire(ctx.datasource, "rw", {
-            allowReadonlyFallbackForMutations: opts.allowReadonlyFallbackForMutations,
+            database: ctx.database,
         });
         const active = this.beginQuery(queryId, session, ctx, "rw", startedAt);
         try {
@@ -133,11 +163,16 @@ export class SqlExecutorImpl {
             };
         }
         catch (error) {
-            try {
-                await session.execute("ROLLBACK", { timeoutMs });
+            if (isTimeoutError(error)) {
+                await cancelTimedOutSession(session, error);
             }
-            catch {
-                // Ignore rollback failure and keep original error.
+            else {
+                try {
+                    await session.execute("ROLLBACK", { timeoutMs });
+                }
+                catch {
+                    // Ignore rollback failure and keep original error.
+                }
             }
             const durationMs = this.now() - startedAt;
             this.completeQuery(active.queryId, active.cancelRequested ? "cancelled" : "failed", durationMs, error);
@@ -245,5 +280,13 @@ export class SqlExecutorImpl {
     }
 }
 export function createSqlExecutor(options) {
-    return new SqlExecutorImpl(options);
+    const executor = new SqlExecutorImpl(options);
+    const limiter = new QueryConcurrencyLimiter(options.maxConcurrentQueries ?? 8, options.maxQueuedQueries ?? 32, options.queueTimeoutMs ?? 5000);
+    return {
+        explain: (sql, ctx) => limiter.run(() => executor.explain(sql, ctx)),
+        executeReadonly: (sql, ctx, opts) => limiter.run(() => executor.executeReadonly(sql, ctx, opts)),
+        executeMutation: (sql, ctx, opts) => limiter.run(() => executor.executeMutation(sql, ctx, opts)),
+        getQueryStatus: (queryId) => executor.getQueryStatus(queryId),
+        cancelQuery: (queryId) => executor.cancelQuery(queryId),
+    };
 }

package/dist/executor/types.d.ts

@@ -9,13 +9,15 @@ export interface ReadonlyOptions {
     maxRows?: number;
     maxColumns?: number;
     maxFieldChars?: number;
+    maxResultBytes?: number;
+    maxBlobBytes?: number;
+    maskAllColumns?: boolean;
     timeoutMs?: number;
     sensitiveColumns?: Iterable<string>;
     sensitiveStrategy?: SensitiveStrategy;
 }
 export interface MutationOptions {
     timeoutMs?: number;
-    allowReadonlyFallbackForMutations?: boolean;
 }
 export interface QueryResult {
     queryId: string;
@@ -27,6 +29,8 @@ export interface QueryResult {
     rowTruncated: boolean;
     columnTruncated: boolean;
     fieldTruncated: boolean;
+    byteTruncated: boolean;
+    returnedBytes: number;
     redactedColumns: string[];
     droppedColumns: string[];
     truncatedColumns: string[];

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { TaurusDBEngine } from "./engine.js";
 export type { EnhancedExplainResult, ConfirmationOutcome, DataSourceInfo, IssueConfirmationInput, TaurusDBEngineCreateOptions, TaurusDBEngineDeps, } from "./engine.js";
+export { createJsonlAuditWriter, JsonlAuditWriter, type AuditDecision, type AuditEvent, type AuditWriter, type JsonlAuditWriterOptions, } from "./audit/jsonl-writer.js";
 export { createConfigFromEnv, getConfig, redactConfigForLog, resetConfigForTests, } from "./config/index.js";
 export type { Config } from "./config/index.js";
 export { createSqlProfileLoader, RuntimeOverrideProfileLoader, } from "./auth/sql-profile-loader.js";
@@ -7,13 +8,15 @@ export type { DataSourceProfile, DatabaseEngine, ProfileLoader, RuntimeDataSourc
 export { DatasourceResolutionError } from "./context/datasource-resolver.js";
 export type { DatasourceResolveInput, DatasourceResolver, RuntimeLimits, SessionContext, } from "./context/session-context.js";
 export { ConnectionPoolError } from "./executor/connection-pool.js";
+export { QueryConcurrencyError } from "./executor/concurrency-limiter.js";
+export { buildServerBoundedReadonlySql } from "./executor/bounded-sql.js";
 export type { CancelResult, ExplainResult, MutationOptions, MutationResult, QueryResult, QueryStatus, ReadonlyOptions, SqlExecutor, } from "./executor/sql-executor.js";
 export { createCapabilityProbe } from "./capability/probe.js";
 export type { CapabilityProbe } from "./capability/probe.js";
 export { UnsupportedFeatureError } from "./capability/types.js";
 export type { CapabilitySnapshot, FeatureMatrix, FeatureStatus, KernelInfo, TaurusFeatureName, } from "./capability/types.js";
-export { createConfirmationStore, InMemoryConfirmationStore, } from "./safety/confirmation-store.js";
-export type { ConfirmationStore, ConfirmationToken, ConfirmationValidationResult, IssueInput, } from "./safety/confirmation-store.js";
+export { createConfirmationStore, InMemoryConfirmationStore, parseApprovalRequest, signApprovalRequest, } from "./safety/confirmation-store.js";
+export type { ConfirmationStore, ConfirmationRequest, ConfirmationValidationResult, IssueInput, } from "./safety/confirmation-store.js";
 export { createGuardrail } from "./safety/guardrail.js";
 export type { Guardrail, GuardrailDecision, GuardrailRuntimeLimits, InspectInput, } from "./safety/guardrail.js";
 export type { ExplainRiskSummary, RiskLevel, ValidationResult } from "./safety/sql-validator.js";
@@ -27,7 +30,13 @@ export { logger, withTaskContext } from "./utils/logger.js";
 export { CloudTaurusInstanceClient, createCloudTaurusInstanceClient, } from "./cloud/instances.js";
 export type { CloudTaurusInstanceSummary, ListCloudTaurusInstancesInput, } from "./cloud/instances.js";
 export { canAuthenticateHuaweiCloudRequests, fetchHuaweiCloud, getHuaweiCloudAuthFromConfig, hasHuaweiCloudCredentialAuth, inferHuaweiCloudRegionFromEndpoint, resolveHuaweiCloudProjectId, } from "./cloud/auth.js";
-export type { HuaweiCloudAuthOptions } from "./cloud/auth.js";
+export type { HuaweiCloudAuthOptions, HuaweiCloudCredentialProvider, HuaweiCloudCredentials, } from "./cloud/auth.js";
+export { createLinuxSecretServiceCredentialProvider, createMacOsKeychainCredentialProvider, createSystemCredentialProvider, createWindowsCredentialManagerProvider, } from "./cloud/keychain.js";
+export type { LinuxSecretServiceCredentialProviderOptions, MacOsKeychainCredentialProviderOptions, SystemCredentialProviderOptions, WindowsCredentialManagerProviderOptions, } from "./cloud/keychain.js";
+export { createHuaweiKmsSecretResolver } from "./cloud/kms.js";
+export type { HuaweiKmsSecretResolverOptions } from "./cloud/kms.js";
+export { createHuaweiCsmsSecretResolver } from "./cloud/csms.js";
+export type { HuaweiCsmsSecretResolverOptions } from "./cloud/csms.js";
 export { FlashbackNoViewError, formatTimestamp as formatFlashbackTimestamp, } from "./taurus/flashback.js";
 export type { FlashbackInput, FlashbackNoViewDetails, } from "./taurus/flashback.js";
 export { buildListRecycleBinSql, buildRestoreRecycleBinTableSql, RECYCLE_BIN_DATABASE, } from "./taurus/recycle-bin.js";
@@ -35,6 +44,6 @@ export type { RecycleBinListResult, RecycleBinRestoreResult, RestoreRecycleBinTa
 export { createPlaceholderDiagnosticResult } from "./diagnostics/types.js";
 export { buildResolveSlowSqlInput, createSlowSqlSource, TaurusApiSlowSqlSource, } from "./diagnostics/slow-sql-source.js";
 export { CesMetricsSource, createMetricsSource, } from "./diagnostics/metrics-source.js";
-export type { DbHotspotItem, DbHotspotResult, DiagnosticBaseInput, DiagnosticConfidence, DiagnosticEvidenceItem, DiagnosticEvidenceLevel, DiagnosticNextToolInput, DiagnoseDbHotspotInput, DiagnoseServiceLatencyInput, FindTopSlowSqlInput, FindTopSlowSqlResult, DiagnosticResult, DiagnosticRootCauseCandidate, DiagnosticSeverity, DiagnosticStatus, ServiceLatencyCandidate, ServiceLatencyResult, ServiceLatencySuspectedCategory, DiagnosticSuspiciousEntities, DiagnosticToolName, DiagnosisWindow, DiagnoseConnectionSpikeInput, DiagnoseLockContentionInput, DiagnoseSlowQueryInput, DiagnoseStoragePressureInput, PlaceholderDiagnosticOptions, TopSlowSqlItem, } from "./diagnostics/types.js";
+export type { DbHotspotItem, DbHotspotResult, DiagnosticBaseInput, DiagnosticConfidence, DiagnosticEvidenceItem, DiagnosticEvidenceLevel, DiagnosticNextToolInput, DiagnoseDbHotspotInput, DiagnoseServiceLatencyInput, FindTopSlowSqlInput, FindTopSlowSqlResult, DiagnosticResult, DiagnosticRootCauseCandidate, DiagnosticSeverity, DiagnosticStatus, ServiceLatencyCandidate, ServiceLatencyResult, ServiceLatencySuspectedCategory, DiagnosticSuspiciousEntities, DiagnosticToolName, DiagnosisWindow, DiagnoseConnectionSpikeInput, DiagnoseLockContentionInput, DiagnoseReplicationLagInput, DiagnoseSlowQueryInput, DiagnoseStoragePressureInput, PlaceholderDiagnosticOptions, TopSlowSqlItem, } from "./diagnostics/types.js";
 export type { ExternalSlowSqlSample, ResolveSlowSqlInput, SlowSqlSource, } from "./diagnostics/slow-sql-source.js";
 export type { MetricAlias, MetricPoint, MetricSummary, MetricsSource, QueryMetricsInput, } from "./diagnostics/metrics-source.js";

package/dist/index.js

@@ -1,11 +1,14 @@
 export { TaurusDBEngine } from "./engine.js";
+export { createJsonlAuditWriter, JsonlAuditWriter, } from "./audit/jsonl-writer.js";
 export { createConfigFromEnv, getConfig, redactConfigForLog, resetConfigForTests, } from "./config/index.js";
 export { createSqlProfileLoader, RuntimeOverrideProfileLoader, } from "./auth/sql-profile-loader.js";
 export { DatasourceResolutionError } from "./context/datasource-resolver.js";
 export { ConnectionPoolError } from "./executor/connection-pool.js";
+export { QueryConcurrencyError } from "./executor/concurrency-limiter.js";
+export { buildServerBoundedReadonlySql } from "./executor/bounded-sql.js";
 export { createCapabilityProbe } from "./capability/probe.js";
 export { UnsupportedFeatureError } from "./capability/types.js";
-export { createConfirmationStore, InMemoryConfirmationStore, } from "./safety/confirmation-store.js";
+export { createConfirmationStore, InMemoryConfirmationStore, parseApprovalRequest, signApprovalRequest, } from "./safety/confirmation-store.js";
 export { createGuardrail } from "./safety/guardrail.js";
 export { SchemaIntrospectionError } from "./schema/introspector.js";
 export { ErrorCode, formatBlocked, formatConfirmationRequired, formatError, formatSuccess, } from "./utils/formatter.js";
@@ -14,6 +17,9 @@ export { generateQueryId, generateTaskId } from "./utils/id.js";
 export { logger, withTaskContext } from "./utils/logger.js";
 export { CloudTaurusInstanceClient, createCloudTaurusInstanceClient, } from "./cloud/instances.js";
 export { canAuthenticateHuaweiCloudRequests, fetchHuaweiCloud, getHuaweiCloudAuthFromConfig, hasHuaweiCloudCredentialAuth, inferHuaweiCloudRegionFromEndpoint, resolveHuaweiCloudProjectId, } from "./cloud/auth.js";
+export { createLinuxSecretServiceCredentialProvider, createMacOsKeychainCredentialProvider, createSystemCredentialProvider, createWindowsCredentialManagerProvider, } from "./cloud/keychain.js";
+export { createHuaweiKmsSecretResolver } from "./cloud/kms.js";
+export { createHuaweiCsmsSecretResolver } from "./cloud/csms.js";
 export { FlashbackNoViewError, formatTimestamp as formatFlashbackTimestamp, } from "./taurus/flashback.js";
 export { buildListRecycleBinSql, buildRestoreRecycleBinTableSql, RECYCLE_BIN_DATABASE, } from "./taurus/recycle-bin.js";
 export { createPlaceholderDiagnosticResult } from "./diagnostics/types.js";

package/dist/safety/confirmation-store.d.ts

@@ -1,5 +1,20 @@
 import type { SessionContext } from "../context/session-context.js";
 import type { RiskLevel, ValidationResult } from "./sql-validator.js";
+export type ApprovalRequestPayload = {
+    version: 1;
+    requestId: string;
+    sqlHash: string;
+    datasource: string;
+    database?: string;
+    host?: string;
+    port?: number;
+    projectId?: string;
+    instanceId?: string;
+    nodeId?: string;
+    riskLevel: RiskLevel;
+    issuedAt: number;
+    expiresAt: number;
+};
 export type IssueInput = {
     sqlHash: string;
     normalizedSql: string;
@@ -7,38 +22,46 @@ export type IssueInput = {
     riskLevel: RiskLevel;
     ttlSeconds?: number;
 };
-export type ConfirmationToken = {
-    token: string;
+export type ConfirmationRequest = {
+    request: string;
+    requestId: string;
     issuedAt: number;
     expiresAt: number;
 };
 export type ConfirmationValidationResult = ValidationResult & {
     valid: boolean;
+    actor?: string;
     reason?: string;
 };
 export interface ConfirmationStore {
-    issue(input: IssueInput): Promise<ConfirmationToken>;
+    issue(input: IssueInput): Promise<ConfirmationRequest>;
     validate(token: string, currentSql: string, ctx: SessionContext): Promise<ConfirmationValidationResult>;
-    revoke(token: string): Promise<void>;
+    revoke(requestId: string): Promise<void>;
 }
 export type ConfirmationStoreOptions = {
+    approvalSecret?: string | Buffer;
     ttlSeconds?: number;
     cleanupIntervalMs?: number;
+    maxEntries?: number;
     now?: () => number;
     randomBytesFn?: (size: number) => Buffer;
 };
+export declare function parseApprovalRequest(request: string): ApprovalRequestPayload;
+export declare function signApprovalRequest(request: string, actor: string, secret: string | Buffer): string;
 export declare class InMemoryConfirmationStore implements ConfirmationStore {
     private readonly entries;
     private readonly now;
     private readonly ttlSeconds;
+    private readonly maxEntries;
     private readonly randomBytesFn;
+    private readonly approvalSecret?;
     private cleanupTimer?;
     constructor(options?: ConfirmationStoreOptions);
-    issue(input: IssueInput): Promise<ConfirmationToken>;
+    issue(input: IssueInput): Promise<ConfirmationRequest>;
     validate(token: string, currentSql: string, ctx: SessionContext): Promise<ConfirmationValidationResult>;
-    revoke(token: string): Promise<void>;
+    revoke(requestId: string): Promise<void>;
     stop(): void;
     cleanupExpired(now?: number): void;
-    private generateUniqueToken;
+    private generateUniqueRequestId;
 }
 export declare function createConfirmationStore(options?: ConfirmationStoreOptions): ConfirmationStore;