taurusdb-core 0.1.0

package/dist/cloud/auth.js

@@ -0,0 +1,198 @@
+import { createHash, createHmac } from "node:crypto";
+function readString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function sha256Hex(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function hmacSha256Hex(secret, value) {
+    return createHmac("sha256", secret).update(value, "utf8").digest("hex");
+}
+function normalizeHeaderValue(value) {
+    return value.trim().replace(/\s+/g, " ");
+}
+function encodeRfc3986(value) {
+    return encodeURIComponent(value).replace(/[!'()*]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function buildCanonicalUri(pathname) {
+    const segments = pathname.split("/").map((segment) => encodeRfc3986(segment));
+    let normalized = segments.join("/");
+    if (!normalized.startsWith("/")) {
+        normalized = `/${normalized}`;
+    }
+    // Huawei Cloud API signing requires the canonical URI to end with a slash.
+    return normalized.endsWith("/") ? normalized : `${normalized}/`;
+}
+function buildCanonicalQueryString(url) {
+    const pairs = [...url.searchParams.entries()].sort((left, right) => {
+        if (left[0] === right[0]) {
+            return left[1].localeCompare(right[1]);
+        }
+        return left[0].localeCompare(right[0]);
+    });
+    return pairs
+        .map(([key, value]) => `${encodeRfc3986(key)}=${encodeRfc3986(value)}`)
+        .join("&");
+}
+function formatSdkDate(now) {
+    return now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+function inferRegionFromUrl(url) {
+    const labels = url.hostname.split(".");
+    return labels.length >= 3 ? labels[1] : undefined;
+}
+function buildHeaderMap(headers, url, sdkDate, securityToken) {
+    const merged = new Headers(headers);
+    merged.set("host", url.host);
+    merged.set("x-sdk-date", sdkDate);
+    if (securityToken) {
+        merged.set("x-security-token", securityToken);
+    }
+    const map = new Map();
+    for (const [key, value] of merged.entries()) {
+        map.set(key.toLowerCase(), normalizeHeaderValue(value));
+    }
+    return new Map([...map.entries()].sort(([left], [right]) => left.localeCompare(right)));
+}
+function buildAuthorization(method, url, headers, body, accessKeyId, secretAccessKey) {
+    const canonicalHeaders = [...headers.entries()]
+        .map(([key, value]) => `${key}:${value}\n`)
+        .join("");
+    const signedHeaders = [...headers.keys()].join(";");
+    const canonicalRequest = [
+        method.toUpperCase(),
+        buildCanonicalUri(url.pathname || "/"),
+        buildCanonicalQueryString(url),
+        canonicalHeaders,
+        signedHeaders,
+        sha256Hex(body),
+    ].join("\n");
+    const stringToSign = `SDK-HMAC-SHA256\n${headers.get("x-sdk-date")}\n${sha256Hex(canonicalRequest)}`;
+    const signature = hmacSha256Hex(secretAccessKey, stringToSign);
+    return `SDK-HMAC-SHA256 Access=${accessKeyId}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+}
+function requireAksk(auth) {
+    const accessKeyId = readString(auth.accessKeyId);
+    const secretAccessKey = readString(auth.secretAccessKey);
+    if (!accessKeyId || !secretAccessKey) {
+        throw new Error("Huawei Cloud request authentication is not configured. Provide TAURUSDB_CLOUD_AUTH_TOKEN or TAURUSDB_CLOUD_ACCESS_KEY_ID and TAURUSDB_CLOUD_SECRET_ACCESS_KEY.");
+    }
+    return { accessKeyId, secretAccessKey };
+}
+export function canAuthenticateHuaweiCloudRequests(auth) {
+    return Boolean(readString(auth.authToken) ||
+        (readString(auth.accessKeyId) && readString(auth.secretAccessKey)));
+}
+export async function fetchHuaweiCloud(options) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const method = options.method ?? "GET";
+    const url = new URL(options.url);
+    const body = options.body ?? "";
+    const authToken = readString(options.auth.authToken);
+    const headers = new Headers(options.headers);
+    if (authToken) {
+        headers.set("x-auth-token", authToken);
+        return fetchImpl(url, {
+            method,
+            headers,
+            body: options.body,
+        });
+    }
+    const { accessKeyId, secretAccessKey } = requireAksk(options.auth);
+    const sdkDate = formatSdkDate(new Date());
+    const headerMap = buildHeaderMap(headers, url, sdkDate, readString(options.auth.securityToken));
+    headerMap.set("authorization", buildAuthorization(method, url, headerMap, body, accessKeyId, secretAccessKey));
+    return fetchImpl(url, {
+        method,
+        headers: Object.fromEntries(headerMap.entries()),
+        body: options.body,
+    });
+}
+function buildIamEndpoint(auth) {
+    const explicit = readString(auth.iamEndpoint);
+    if (explicit) {
+        return explicit.replace(/\/+$/g, "");
+    }
+    const region = readString(auth.region);
+    if (!region) {
+        return undefined;
+    }
+    const domainSuffix = readString(auth.domainSuffix) ?? "myhuaweicloud.com";
+    return `https://iam.${region}.${domainSuffix}`;
+}
+function parseProjectItems(payload) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        return [];
+    }
+    const record = payload;
+    const projects = record.projects ?? record.project_info ?? record.items;
+    if (!Array.isArray(projects)) {
+        return [];
+    }
+    return projects.filter((item) => item !== null && typeof item === "object" && !Array.isArray(item));
+}
+export async function resolveHuaweiCloudProjectId(auth, fetchImpl) {
+    const explicitProjectId = readString(auth.projectId);
+    if (explicitProjectId) {
+        return explicitProjectId;
+    }
+    const iamEndpoint = buildIamEndpoint(auth);
+    const region = readString(auth.region);
+    if (!iamEndpoint || !region) {
+        return undefined;
+    }
+    const response = await fetchHuaweiCloud({
+        url: `${iamEndpoint}/v3/auth/projects`,
+        headers: {
+            "content-type": "application/json",
+        },
+        auth,
+        fetchImpl,
+    });
+    const payload = (await response.json().catch(() => ({})));
+    if (!response.ok) {
+        const record = payload && typeof payload === "object" && !Array.isArray(payload)
+            ? payload
+            : {};
+        const code = readString(record.error_code) ?? readString(record.code);
+        const message = readString(record.error_msg) ?? readString(record.message);
+        throw new Error(`Huawei Cloud project lookup failed with status ${response.status}${code ? ` (${code})` : ""}${message ? `: ${message}` : ""}.`);
+    }
+    const projects = parseProjectItems(payload);
+    const exactMatch = projects.find((project) => readString(project.name) === region);
+    if (exactMatch) {
+        return readString(exactMatch.id);
+    }
+    if (projects.length === 1) {
+        return readString(projects[0].id);
+    }
+    throw new Error(`Unable to resolve project id for region ${region}. Set TAURUSDB_CLOUD_PROJECT_ID explicitly or restrict the account to a single visible project in that region.`);
+}
+export function getHuaweiCloudAuthFromConfig(config) {
+    return {
+        region: config.cloud?.region,
+        projectId: config.cloud?.projectId,
+        authToken: config.cloud?.authToken,
+        accessKeyId: config.cloud?.accessKeyId,
+        secretAccessKey: config.cloud?.secretAccessKey,
+        securityToken: config.cloud?.securityToken,
+        domainSuffix: config.cloud?.domainSuffix,
+        iamEndpoint: config.cloud?.iamEndpoint,
+        language: config.cloud?.language,
+    };
+}
+export function hasHuaweiCloudCredentialAuth(config) {
+    return canAuthenticateHuaweiCloudRequests(getHuaweiCloudAuthFromConfig(config));
+}
+export function inferHuaweiCloudRegionFromEndpoint(endpoint) {
+    const normalized = readString(endpoint);
+    if (!normalized) {
+        return undefined;
+    }
+    try {
+        return inferRegionFromUrl(new URL(normalized));
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/cloud/instances.d.ts

@@ -0,0 +1,46 @@
+import type { Config } from "../config/index.js";
+import { type HuaweiCloudAuthOptions } from "./auth.js";
+export interface ListCloudTaurusInstancesInput {
+    name?: string;
+    id?: string;
+    ip?: string;
+    offset?: number;
+    limit?: number;
+}
+export interface CloudTaurusInstanceSummary {
+    id: string;
+    name: string;
+    status?: string;
+    mode?: string;
+    region?: string;
+    datastoreVersion?: string;
+    vpcId?: string;
+    subnetId?: string;
+    privateIps: string[];
+    publicIps: string[];
+    hostnames: string[];
+    port?: string;
+    nodeIds: string[];
+    primaryNodeId?: string;
+    created?: string;
+    updated?: string;
+}
+type CloudInstanceClientOptions = {
+    endpoint: string;
+    auth: HuaweiCloudAuthOptions;
+    language: "en-us" | "zh-cn";
+    fetchImpl?: typeof fetch;
+};
+export declare class CloudTaurusInstanceClient {
+    private readonly endpoint;
+    private readonly auth;
+    private readonly language;
+    private readonly fetchImpl;
+    private resolvedProjectId?;
+    constructor(options: CloudInstanceClientOptions);
+    getProjectId(): Promise<string>;
+    list(input?: ListCloudTaurusInstancesInput): Promise<CloudTaurusInstanceSummary[]>;
+    resolveByHostPort(host: string, port?: string | number): Promise<CloudTaurusInstanceSummary>;
+}
+export declare function createCloudTaurusInstanceClient(config: Config): CloudTaurusInstanceClient | undefined;
+export {};

package/dist/cloud/instances.js

@@ -0,0 +1,224 @@
+import { fetchHuaweiCloud, getHuaweiCloudAuthFromConfig, resolveHuaweiCloudProjectId, } from "./auth.js";
+function readString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function readStringList(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((item) => readString(item))
+        .filter((item) => item !== undefined);
+}
+function readNestedAddressList(value, key) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            return undefined;
+        }
+        return readString(item[key]);
+    })
+        .filter((item) => item !== undefined);
+}
+function clampInteger(value, fallback, min, max) {
+    if (value === undefined || !Number.isInteger(value)) {
+        return fallback;
+    }
+    return Math.min(Math.max(value, min), max);
+}
+function buildQueryString(input) {
+    const params = new URLSearchParams();
+    const offset = clampInteger(input.offset, 0, 0, 10_000);
+    const limit = clampInteger(input.limit, 50, 1, 100);
+    params.set("offset", String(offset));
+    params.set("limit", String(limit));
+    const name = readString(input.name);
+    if (name) {
+        params.set("name", name);
+    }
+    const id = readString(input.id);
+    if (id) {
+        params.set("id", id);
+    }
+    const ip = readString(input.ip);
+    if (ip) {
+        params.set("ip", ip);
+    }
+    return params.toString();
+}
+function parseInstanceSummary(item) {
+    const id = readString(item.id);
+    const name = readString(item.name);
+    if (!id || !name) {
+        return undefined;
+    }
+    const nodes = Array.isArray(item.nodes)
+        ? item.nodes.filter((entry) => entry !== null && typeof entry === "object" && !Array.isArray(entry))
+        : [];
+    const nodeIds = nodes
+        .map((entry) => readString(entry.id) ?? readString(entry.node_id))
+        .filter((entry) => entry !== undefined);
+    const primaryNode = nodes.find((entry) => {
+        const role = readString(entry.role) ??
+            readString(entry.type) ??
+            readString(entry.node_type);
+        return Boolean(role && /(master|primary|writer|readwrite)/i.test(role));
+    }) ?? (nodes.length === 1 ? nodes[0] : undefined);
+    const port = readString(item.port) ?? readString(item.db_port);
+    return {
+        id,
+        name,
+        status: readString(item.status),
+        mode: readString(item.mode),
+        region: readString(item.region),
+        datastoreVersion: readString(item.datastore?.version) ??
+            readString(item.db_type),
+        vpcId: readString(item.vpc_security_group?.vpc_id) ??
+            readString(item.vpc_id),
+        subnetId: readString(item.vpc_security_group?.subnet_id) ??
+            readString(item.subnet_id),
+        privateIps: [
+            ...readStringList(item.private_ips),
+            ...readStringList(item.proxy_ips),
+            ...readStringList(item.readonly_private_ips),
+            ...readNestedAddressList(item.nodes, "private_ip"),
+        ].filter((value, index, allItems) => allItems.indexOf(value) === index),
+        publicIps: readStringList(item.public_ips),
+        hostnames: [
+            readString(item.private_dns),
+            readString(item.public_dns),
+            readString(item.db_domain),
+            readString(item.readonly_domain),
+            readString(item.alias),
+        ].filter((value, index, allItems) => value !== undefined && allItems.indexOf(value) === index),
+        port,
+        nodeIds,
+        primaryNodeId: readString(primaryNode?.id) ??
+            readString(primaryNode?.node_id) ??
+            (nodeIds.length === 1 ? nodeIds[0] : undefined),
+        created: readString(item.created),
+        updated: readString(item.updated),
+    };
+}
+function normalizeHost(host) {
+    return host.trim().toLowerCase();
+}
+function normalizePort(port) {
+    if (typeof port === "number" && Number.isFinite(port)) {
+        return String(port);
+    }
+    return readString(typeof port === "string" ? port : undefined);
+}
+async function parseJsonObject(response) {
+    const payload = (await response.json());
+    return payload && typeof payload === "object" && !Array.isArray(payload)
+        ? payload
+        : {};
+}
+export class CloudTaurusInstanceClient {
+    endpoint;
+    auth;
+    language;
+    fetchImpl;
+    resolvedProjectId;
+    constructor(options) {
+        this.endpoint = options.endpoint.replace(/\/+$/g, "");
+        this.auth = options.auth;
+        this.language = options.language;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+        this.resolvedProjectId = readString(options.auth.projectId);
+    }
+    async getProjectId() {
+        if (!this.resolvedProjectId) {
+            this.resolvedProjectId = await resolveHuaweiCloudProjectId(this.auth, this.fetchImpl);
+        }
+        if (!this.resolvedProjectId) {
+            throw new Error("Cloud instance discovery could not resolve a Huawei Cloud project id. Provide TAURUSDB_CLOUD_PROJECT_ID or configure region plus AK/SK credentials.");
+        }
+        return this.resolvedProjectId;
+    }
+    async list(input = {}) {
+        const query = buildQueryString(input);
+        const projectId = await this.getProjectId();
+        const response = await fetchHuaweiCloud({
+            url: `${this.endpoint}/v3/${projectId}/instances?${query}`,
+            headers: {
+                "content-type": "application/json",
+                "x-language": this.language,
+            },
+            auth: this.auth,
+            fetchImpl: this.fetchImpl,
+        });
+        if (!response.ok) {
+            const payload = (await parseJsonObject(response).catch(() => ({})));
+            const code = readString(payload.error_code) ?? readString(payload.code);
+            const message = readString(payload.error_msg) ?? readString(payload.message);
+            throw new Error(`Cloud instance list request failed with status ${response.status}${code ? ` (${code})` : ""}${message ? `: ${message}` : ""}.`);
+        }
+        const payload = await parseJsonObject(response);
+        const instances = Array.isArray(payload.instances)
+            ? payload.instances
+            : Array.isArray(payload.instance_info)
+                ? payload.instance_info
+                : [];
+        return instances
+            .map((item) => item && typeof item === "object" && !Array.isArray(item)
+            ? parseInstanceSummary(item)
+            : undefined)
+            .filter((item) => item !== undefined);
+    }
+    async resolveByHostPort(host, port) {
+        const normalizedHost = normalizeHost(host);
+        const normalizedPort = normalizePort(port);
+        const instances = await this.list({
+            ip: normalizedHost,
+            limit: 100,
+        });
+        const matches = instances.filter((item) => {
+            const hosts = [
+                ...item.privateIps,
+                ...item.publicIps,
+                ...item.hostnames,
+            ].map(normalizeHost);
+            if (!hosts.includes(normalizedHost)) {
+                return false;
+            }
+            if (!normalizedPort || !item.port) {
+                return true;
+            }
+            return item.port === normalizedPort;
+        });
+        if (matches.length === 1) {
+            return matches[0];
+        }
+        if (matches.length === 0) {
+            throw new Error(`No cloud instance matched datasource address ${host}${normalizedPort ? `:${normalizedPort}` : ""}. Use list_cloud_taurus_instances and provide an explicit instance id.`);
+        }
+        throw new Error(`Multiple cloud instances matched datasource address ${host}${normalizedPort ? `:${normalizedPort}` : ""}. Use list_cloud_taurus_instances and select an explicit instance id.`);
+    }
+}
+export function createCloudTaurusInstanceClient(config) {
+    const endpoint = config.cloud?.apiEndpoint ??
+        config.slowSqlSource?.taurusApi?.endpoint ??
+        config.metricsSource?.ces?.endpoint;
+    const language = config.cloud?.language ?? "zh-cn";
+    if (!endpoint) {
+        return undefined;
+    }
+    return new CloudTaurusInstanceClient({
+        endpoint,
+        auth: {
+            ...getHuaweiCloudAuthFromConfig(config),
+            projectId: config.cloud?.projectId ??
+                config.slowSqlSource?.taurusApi?.projectId ??
+                config.metricsSource?.ces?.projectId,
+            authToken: config.cloud?.authToken ??
+                config.slowSqlSource?.taurusApi?.authToken ??
+                config.metricsSource?.ces?.authToken,
+        },
+        language,
+    });
+}

package/dist/config/env.d.ts

@@ -0,0 +1 @@
+export declare function buildRawConfigFromEnv(env: NodeJS.ProcessEnv): Record<string, unknown>;

package/dist/config/env.js

@@ -0,0 +1,194 @@
+import os from "node:os";
+import path from "node:path";
+const HUAWEI_CLOUD_DEFAULT_DOMAIN_SUFFIX = "myhuaweicloud.com";
+const REGION_PATTERN = /^[a-z]{2}(?:-[a-z0-9]+)+-\d+$/i;
+function readString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function parseBoolean(value, name) {
+    const normalized = readString(value)?.toLowerCase();
+    if (normalized === undefined) {
+        return undefined;
+    }
+    if (normalized === "true" ||
+        normalized === "1" ||
+        normalized === "yes" ||
+        normalized === "on") {
+        return true;
+    }
+    if (normalized === "false" ||
+        normalized === "0" ||
+        normalized === "no" ||
+        normalized === "off") {
+        return false;
+    }
+    throw new Error(`Invalid boolean for ${name}: "${value}". Expected one of true/false/1/0/yes/no/on/off.`);
+}
+function parseInteger(value, name) {
+    const normalized = readString(value);
+    if (normalized === undefined) {
+        return undefined;
+    }
+    if (!/^-?\d+$/.test(normalized)) {
+        throw new Error(`Invalid integer for ${name}: "${value}".`);
+    }
+    const parsed = Number.parseInt(normalized, 10);
+    if (!Number.isFinite(parsed) || Number.isNaN(parsed)) {
+        throw new Error(`Invalid integer for ${name}: "${value}".`);
+    }
+    return parsed;
+}
+function pickFirstDefined(...values) {
+    for (const value of values) {
+        if (value !== undefined) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function hasSqlTemplateInputs(env) {
+    return Boolean(readString(env.TAURUSDB_SQL_DSN) ||
+        readString(env.TAURUSDB_SQL_HOST) ||
+        readString(env.TAURUSDB_SQL_DATABASE) ||
+        readString(env.TAURUSDB_SQL_USER) ||
+        readString(env.TAURUSDB_SQL_PASSWORD));
+}
+function inferRegionFromValue(value) {
+    const normalized = readString(value);
+    if (!normalized) {
+        return undefined;
+    }
+    const directMatch = normalized.match(REGION_PATTERN);
+    if (directMatch) {
+        return directMatch[0].toLowerCase();
+    }
+    try {
+        const hostname = normalized.includes("://")
+            ? new URL(normalized).hostname
+            : normalized;
+        const labels = hostname.split(".");
+        for (const label of labels) {
+            if (REGION_PATTERN.test(label)) {
+                return label.toLowerCase();
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function buildHuaweiCloudEndpoint(service, region, domainSuffix) {
+    if (!region) {
+        return undefined;
+    }
+    return `https://${service}.${region}.${domainSuffix ?? HUAWEI_CLOUD_DEFAULT_DOMAIN_SUFFIX}`;
+}
+function expandTildePath(inputPath) {
+    if (!inputPath) {
+        return undefined;
+    }
+    if (inputPath === "~") {
+        return os.homedir();
+    }
+    if (inputPath.startsWith("~/")) {
+        return path.join(os.homedir(), inputPath.slice(2));
+    }
+    return inputPath;
+}
+export function buildRawConfigFromEnv(env) {
+    const cloudDasEnabled = parseBoolean(env.TAURUSDB_CLOUD_ENABLE_DAS, "TAURUSDB_CLOUD_ENABLE_DAS");
+    const cloudCesEnabled = parseBoolean(env.TAURUSDB_CLOUD_ENABLE_CES, "TAURUSDB_CLOUD_ENABLE_CES");
+    const cloudTaurusApiEnabled = parseBoolean(env.TAURUSDB_CLOUD_ENABLE_TAURUS_API, "TAURUSDB_CLOUD_ENABLE_TAURUS_API");
+    const cloudDomainSuffix = readString(env.TAURUSDB_CLOUD_DOMAIN_SUFFIX) ??
+        HUAWEI_CLOUD_DEFAULT_DOMAIN_SUFFIX;
+    const cloudRegion = pickFirstDefined(readString(env.TAURUSDB_CLOUD_REGION), inferRegionFromValue(env.TAURUSDB_SQL_HOST), inferRegionFromValue(env.TAURUSDB_SLOW_SQL_SOURCE_DAS_ENDPOINT), inferRegionFromValue(env.TAURUSDB_METRICS_SOURCE_CES_ENDPOINT), inferRegionFromValue(env.TAURUSDB_SLOW_SQL_SOURCE_TAURUS_API_ENDPOINT));
+    const cloudProjectId = readString(env.TAURUSDB_CLOUD_PROJECT_ID);
+    const cloudInstanceId = readString(env.TAURUSDB_CLOUD_INSTANCE_ID);
+    const cloudNodeId = readString(env.TAURUSDB_CLOUD_NODE_ID);
+    const cloudAuthToken = readString(env.TAURUSDB_CLOUD_AUTH_TOKEN);
+    const cloudAccessKeyId = pickFirstDefined(readString(env.TAURUSDB_CLOUD_ACCESS_KEY_ID), readString(env.TAURUSDB_CLOUD_AK));
+    const cloudSecretAccessKey = pickFirstDefined(readString(env.TAURUSDB_CLOUD_SECRET_ACCESS_KEY), readString(env.TAURUSDB_CLOUD_SK));
+    const cloudSecurityToken = pickFirstDefined(readString(env.TAURUSDB_CLOUD_SECURITY_TOKEN), readString(env.TAURUSDB_CLOUD_SESSION_TOKEN));
+    const inferredDatasourceName = hasSqlTemplateInputs(env)
+        ? readString(env.TAURUSDB_SQL_DATASOURCE) ?? "taurus_mcp"
+        : undefined;
+    return {
+        defaultDatasource: readString(env.TAURUSDB_DEFAULT_DATASOURCE) ?? inferredDatasourceName,
+        profilesPath: expandTildePath(readString(env.TAURUSDB_SQL_PROFILES)),
+        enableMutations: parseBoolean(env.TAURUSDB_MCP_ENABLE_MUTATIONS, "TAURUSDB_MCP_ENABLE_MUTATIONS"),
+        cloud: {
+            provider: "huaweicloud",
+            region: cloudRegion,
+            projectId: cloudProjectId,
+            instanceId: cloudInstanceId,
+            nodeId: cloudNodeId,
+            authToken: cloudAuthToken,
+            accessKeyId: cloudAccessKeyId,
+            secretAccessKey: cloudSecretAccessKey,
+            securityToken: cloudSecurityToken,
+            apiEndpoint: buildHuaweiCloudEndpoint("gaussdb", cloudRegion, cloudDomainSuffix),
+            iamEndpoint: buildHuaweiCloudEndpoint("iam", cloudRegion, cloudDomainSuffix),
+            domainSuffix: cloudDomainSuffix,
+            language: readString(env.TAURUSDB_CLOUD_LANGUAGE) ??
+                readString(env.TAURUSDB_SLOW_SQL_SOURCE_TAURUS_API_LANGUAGE),
+        },
+        limits: {
+            maxRows: parseInteger(env.TAURUSDB_MCP_MAX_ROWS, "TAURUSDB_MCP_MAX_ROWS"),
+            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"),
+        },
+        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"),
+        },
+        slowSqlSource: {
+            taurusApi: {
+                enabled: pickFirstDefined(parseBoolean(env.TAURUSDB_SLOW_SQL_SOURCE_TAURUS_API_ENABLED, "TAURUSDB_SLOW_SQL_SOURCE_TAURUS_API_ENABLED"), cloudTaurusApiEnabled),
+                endpoint: pickFirstDefined(readString(env.TAURUSDB_SLOW_SQL_SOURCE_TAURUS_API_ENDPOINT), buildHuaweiCloudEndpoint("gaussdb", cloudRegion, cloudDomainSuffix)),
+                projectId: pickFirstDefined(readString(env.TAURUSDB_SLOW_SQL_SOURCE_TAURUS_API_PROJECT_ID), cloudProjectId),
+                instanceId: pickFirstDefined(readString(env.TAURUSDB_SLOW_SQL_SOURCE_TAURUS_API_INSTANCE_ID), cloudInstanceId),
+                nodeId: pickFirstDefined(readString(env.TAURUSDB_SLOW_SQL_SOURCE_TAURUS_API_NODE_ID), cloudNodeId),
+                authToken: pickFirstDefined(readString(env.TAURUSDB_SLOW_SQL_SOURCE_TAURUS_API_AUTH_TOKEN), cloudAuthToken),
+                language: readString(env.TAURUSDB_SLOW_SQL_SOURCE_TAURUS_API_LANGUAGE),
+                requestTimeoutMs: parseInteger(env.TAURUSDB_SLOW_SQL_SOURCE_TAURUS_API_TIMEOUT_MS, "TAURUSDB_SLOW_SQL_SOURCE_TAURUS_API_TIMEOUT_MS"),
+                defaultLookbackMinutes: parseInteger(env.TAURUSDB_SLOW_SQL_SOURCE_TAURUS_API_DEFAULT_LOOKBACK_MINUTES, "TAURUSDB_SLOW_SQL_SOURCE_TAURUS_API_DEFAULT_LOOKBACK_MINUTES"),
+                maxRecords: parseInteger(env.TAURUSDB_SLOW_SQL_SOURCE_TAURUS_API_MAX_RECORDS, "TAURUSDB_SLOW_SQL_SOURCE_TAURUS_API_MAX_RECORDS"),
+            },
+            das: {
+                enabled: pickFirstDefined(parseBoolean(env.TAURUSDB_SLOW_SQL_SOURCE_DAS_ENABLED, "TAURUSDB_SLOW_SQL_SOURCE_DAS_ENABLED"), cloudDasEnabled, true),
+                endpoint: pickFirstDefined(readString(env.TAURUSDB_SLOW_SQL_SOURCE_DAS_ENDPOINT), buildHuaweiCloudEndpoint("das", cloudRegion, cloudDomainSuffix)),
+                projectId: pickFirstDefined(readString(env.TAURUSDB_SLOW_SQL_SOURCE_DAS_PROJECT_ID), cloudProjectId),
+                instanceId: pickFirstDefined(readString(env.TAURUSDB_SLOW_SQL_SOURCE_DAS_INSTANCE_ID), cloudInstanceId),
+                authToken: pickFirstDefined(readString(env.TAURUSDB_SLOW_SQL_SOURCE_DAS_AUTH_TOKEN), cloudAuthToken),
+                datastoreType: readString(env.TAURUSDB_SLOW_SQL_SOURCE_DAS_DATASTORE_TYPE),
+                requestTimeoutMs: parseInteger(env.TAURUSDB_SLOW_SQL_SOURCE_DAS_TIMEOUT_MS, "TAURUSDB_SLOW_SQL_SOURCE_DAS_TIMEOUT_MS"),
+                defaultLookbackMinutes: parseInteger(env.TAURUSDB_SLOW_SQL_SOURCE_DAS_DEFAULT_LOOKBACK_MINUTES, "TAURUSDB_SLOW_SQL_SOURCE_DAS_DEFAULT_LOOKBACK_MINUTES"),
+                maxRecords: parseInteger(env.TAURUSDB_SLOW_SQL_SOURCE_DAS_MAX_RECORDS, "TAURUSDB_SLOW_SQL_SOURCE_DAS_MAX_RECORDS"),
+                maxPages: parseInteger(env.TAURUSDB_SLOW_SQL_SOURCE_DAS_MAX_PAGES, "TAURUSDB_SLOW_SQL_SOURCE_DAS_MAX_PAGES"),
+            },
+        },
+        metricsSource: {
+            ces: {
+                enabled: pickFirstDefined(parseBoolean(env.TAURUSDB_METRICS_SOURCE_CES_ENABLED, "TAURUSDB_METRICS_SOURCE_CES_ENABLED"), cloudCesEnabled, true),
+                endpoint: pickFirstDefined(readString(env.TAURUSDB_METRICS_SOURCE_CES_ENDPOINT), buildHuaweiCloudEndpoint("ces", cloudRegion, cloudDomainSuffix)),
+                projectId: pickFirstDefined(readString(env.TAURUSDB_METRICS_SOURCE_CES_PROJECT_ID), cloudProjectId),
+                instanceId: pickFirstDefined(readString(env.TAURUSDB_METRICS_SOURCE_CES_INSTANCE_ID), cloudInstanceId),
+                nodeId: pickFirstDefined(readString(env.TAURUSDB_METRICS_SOURCE_CES_NODE_ID), cloudNodeId),
+                authToken: pickFirstDefined(readString(env.TAURUSDB_METRICS_SOURCE_CES_AUTH_TOKEN), cloudAuthToken),
+                namespace: readString(env.TAURUSDB_METRICS_SOURCE_CES_NAMESPACE),
+                instanceDimension: readString(env.TAURUSDB_METRICS_SOURCE_CES_INSTANCE_DIMENSION),
+                nodeDimension: readString(env.TAURUSDB_METRICS_SOURCE_CES_NODE_DIMENSION),
+                period: readString(env.TAURUSDB_METRICS_SOURCE_CES_PERIOD),
+                filter: readString(env.TAURUSDB_METRICS_SOURCE_CES_FILTER),
+                requestTimeoutMs: parseInteger(env.TAURUSDB_METRICS_SOURCE_CES_TIMEOUT_MS, "TAURUSDB_METRICS_SOURCE_CES_TIMEOUT_MS"),
+                defaultLookbackMinutes: parseInteger(env.TAURUSDB_METRICS_SOURCE_CES_DEFAULT_LOOKBACK_MINUTES, "TAURUSDB_METRICS_SOURCE_CES_DEFAULT_LOOKBACK_MINUTES"),
+            },
+        },
+    };
+}

package/dist/config/index.d.ts

@@ -0,0 +1,6 @@
+import { type Config } from "./schema.js";
+export { redactConfigForLog } from "./redaction.js";
+export type { Config } from "./schema.js";
+export declare function createConfigFromEnv(env?: NodeJS.ProcessEnv): Config;
+export declare function getConfig(): Config;
+export declare function resetConfigForTests(): void;