@yejiming/dsh-data-agent 0.0.13 → 0.1.0

package/lib/command.js

@@ -1,2 +1,2 @@
-import { a as formatConnectionStatus, c as parseConnectArguments, i as executeDatabaseCommand, l as parseDatabaseAction, n as DATA_AGENT_TOOL_NAMES, o as inject, r as apply, s as name, t as DATABASE_COMMAND_USAGE } from "./command-utC5MHd9.js";
-export { DATABASE_COMMAND_USAGE, DATA_AGENT_TOOL_NAMES, apply, executeDatabaseCommand, formatConnectionStatus, inject, name, parseConnectArguments, parseDatabaseAction };
+import { a as executeDatabaseCommand, c as isDshTuiPluginLoaded, d as parseDatabaseAction, i as apply, l as name, n as DATA_AGENT_TOOL_NAMES, o as formatConnectionStatus, r as DSH_TUI_PLUGIN_RUNTIME_NAME, s as inject, t as DATABASE_COMMAND_USAGE, u as parseConnectArguments } from "./command-CzzSPmag.js";
+export { DATABASE_COMMAND_USAGE, DATA_AGENT_TOOL_NAMES, DSH_TUI_PLUGIN_RUNTIME_NAME, apply, executeDatabaseCommand, formatConnectionStatus, inject, isDshTuiPluginLoaded, name, parseConnectArguments, parseDatabaseAction };

package/lib/{connections-CHY4uB6z.js → connections-CFXOZTHZ.js}

@@ -1,10 +1,115 @@
-import { c as WORKBENCH_MAX_RESULT_CHARS, d as defaultDatabasePort, f as defaultDatabaseUser, p as isDatabaseType, s as WORKBENCH_MAX_EXPORT_ROWS } from "./defaults-Cngd8Tf8.js";
 import { readdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import { posix, resolve, win32 } from "node:path";
 import z from "schemastery";
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
 import { createClient } from "@clickhouse/client";
+//#region src/database-types.ts
+/**
+* Browser-safe database type descriptors shared by every DSH surface.
+* Keep this module dependency-free: server-only client/process details belong
+* in the database adapters, not in Web or persistence bundles.
+*/
+const DATABASE_TYPES = [
+	"mysql",
+	"postgres",
+	"sqlite",
+	"oracle",
+	"hive",
+	"impala",
+	"clickhouse",
+	"doris",
+	"sqlserver"
+];
+const DATABASE_TYPE_DESCRIPTORS = {
+	mysql: {
+		type: "mysql",
+		label: "MySQL",
+		localeKey: "type.mysql",
+		defaultPort: 3306,
+		defaultUser: "root",
+		fileBased: false
+	},
+	postgres: {
+		type: "postgres",
+		label: "PostgreSQL",
+		localeKey: "type.postgres",
+		defaultPort: 5432,
+		defaultUser: "postgres",
+		fileBased: false
+	},
+	sqlite: {
+		type: "sqlite",
+		label: "SQLite",
+		localeKey: "type.sqlite",
+		defaultPort: 0,
+		defaultUser: "",
+		fileBased: true
+	},
+	oracle: {
+		type: "oracle",
+		label: "Oracle",
+		localeKey: "type.oracle",
+		defaultPort: 1521,
+		defaultUser: "",
+		fileBased: false
+	},
+	hive: {
+		type: "hive",
+		label: "Hive",
+		localeKey: "type.hive",
+		defaultPort: 1e4,
+		defaultUser: "",
+		fileBased: false
+	},
+	impala: {
+		type: "impala",
+		label: "Impala",
+		localeKey: "type.impala",
+		defaultPort: 21050,
+		defaultUser: "",
+		fileBased: false
+	},
+	clickhouse: {
+		type: "clickhouse",
+		label: "ClickHouse",
+		localeKey: "type.clickhouse",
+		defaultPort: 8123,
+		securePort: 8443,
+		defaultUser: "default",
+		fileBased: false
+	},
+	doris: {
+		type: "doris",
+		label: "Apache Doris",
+		localeKey: "type.doris",
+		defaultPort: 9030,
+		defaultUser: "root",
+		fileBased: false
+	},
+	sqlserver: {
+		type: "sqlserver",
+		label: "SQL Server",
+		localeKey: "type.sqlserver",
+		defaultPort: 1433,
+		defaultUser: "sa",
+		fileBased: false
+	}
+};
+function isDatabaseType(value) {
+	return typeof value === "string" && DATABASE_TYPES.includes(value);
+}
+function defaultDatabasePort(type, secure = false) {
+	const descriptor = DATABASE_TYPE_DESCRIPTORS[type];
+	return secure && descriptor.securePort !== void 0 ? descriptor.securePort : descriptor.defaultPort;
+}
+function defaultDatabaseUser(type) {
+	return DATABASE_TYPE_DESCRIPTORS[type].defaultUser;
+}
+function databaseTypeLabel(type) {
+	return DATABASE_TYPE_DESCRIPTORS[type].label;
+}
+//#endregion
 //#region src/sql.ts
 /**
 * Lightweight SQL-text scanning helpers shared by the sql-cmd tool half and
@@ -1145,6 +1250,40 @@ function parseColumns(type, stdout) {
 	return columns;
 }
 //#endregion
+//#region src/defaults.ts
+/**
+* Package-wide defaults shared by the server half (`src/index.ts`) and the
+* database tool half (`src/tool.ts`). Loader schemas carry these as their
+* defaults so a deployment may override every one of them in cordis.yml.
+* @module @yejiming/dsh-data-agent/defaults
+*/
+/** Preset directory name installed into `$DSH_HOME/.agent-presets/`. */
+const DEFAULT_PRESET_ID = "data-agent";
+/** End-to-end deadline for one `/connect` connectivity check, milliseconds. */
+const DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
+/** End-to-end deadline for one database-tool query, milliseconds. */
+const DEFAULT_QUERY_TIMEOUT_MS = 3e4;
+/** In-memory cap on database-tool captured output (stdout and stderr each). */
+const DEFAULT_MAX_RESULT_CHARS = 2e4;
+/** Hard row cap for one structured Web workbench result/export. */
+const WORKBENCH_MAX_EXPORT_ROWS = 5e4;
+/** Bounded capture size for the larger structured Web workbench result. */
+const WORKBENCH_MAX_RESULT_CHARS = 33554432;
+/** Cap on one /query SQL text length (abuse guard; the wire body stays small). */
+const DEFAULT_MAX_QUERY_CHARS = 65536;
+/** Catalog metadata query deadline. Kept separate from user SQL execution. */
+const DEFAULT_CATALOG_QUERY_TIMEOUT_MS = 3e4;
+/**
+* Per-stream capture budget for one system-catalog query. Catalog metadata is
+* intentionally independent from the much smaller model/interactive SQL
+* result budget because a schema snapshot can contain thousands of objects.
+*/
+const DEFAULT_CATALOG_MAX_RESULT_CHARS = 33554432;
+/** Hard bound on technical assets (including columns) staged by one run. */
+const DEFAULT_CATALOG_MAX_ASSETS = 5e4;
+/** Maximum normalized length of one database or human-authored text field. */
+const DEFAULT_CATALOG_MAX_TEXT_CHARS = 4096;
+//#endregion
 //#region src/client-discovery.ts
 /**
 * Cross-platform database CLI discovery.
@@ -1950,15 +2089,15 @@ function createConnectionService(ctx, options, persistence) {
 			tables: copyTables(connection.tables)
 		};
 	};
-	const queryOptions = (mode, connect = false, maxResultChars = resolvedOptions.maxResultChars) => ({
+	const queryOptions = (mode, connect = false, maxResultChars = resolvedOptions.maxResultChars, catalog = false) => ({
 		clients: resolvedOptions.clients,
-		timeoutMs: connect ? resolvedOptions.connectTimeoutMs : resolvedOptions.queryTimeoutMs,
+		timeoutMs: connect ? resolvedOptions.connectTimeoutMs : catalog ? resolvedOptions.catalogQueryTimeoutMs ?? resolvedOptions.queryTimeoutMs : resolvedOptions.queryTimeoutMs,
 		maxResultChars,
 		...mode !== void 0 ? { mode } : {}
 	});
-	const run = async (connection, sql, signal, introspection = false, connect = false, mode, maxResultChars) => {
+	const run = async (connection, sql, signal, introspection = false, connect = false, mode, maxResultChars, catalog = false) => {
 		try {
-			return redactQueryResult(await runClientQuery(requireContext(), connection, sql, queryOptions(mode, connect, maxResultChars), signal, introspection), connection);
+			return redactQueryResult(await runClientQuery(requireContext(), connection, sql, queryOptions(mode, connect, maxResultChars, catalog), signal, introspection), connection);
 		} catch (error) {
 			const message = redactSecretText(error instanceof Error ? error.message : String(error), [connection.password]);
 			throw new Error(message, error instanceof Error ? { cause: error } : void 0);
@@ -2021,6 +2160,50 @@ function createConnectionService(ctx, options, persistence) {
 			throw error;
 		}
 	};
+	const matchingProfiles = (connection) => (persistence?.listProfiles?.() ?? []).filter((entry) => profileMatchesConnection(entry.profile, connection, resolvedOptions.cwd));
+	const preferredMatches = (matches) => {
+		const preferred = new Set(resolvedOptions.preferredProfileIds?.() ?? []);
+		return matches.filter((entry) => preferred.has(entry.profileId));
+	};
+	const reusableProfileId = (sessionId, connection) => {
+		if (connection.profileId !== void 0) return connection.profileId;
+		const fallback = `session:${sessionId}`;
+		const matches = matchingProfiles(connection);
+		const binding = persistence?.getBinding(sessionId);
+		const boundMatch = binding === void 0 ? void 0 : matches.find((entry) => entry.profileId === binding.profileId);
+		const preferred = preferredMatches(matches);
+		const stableMatches = matches.filter((entry) => !entry.profileId.startsWith("session:"));
+		if (boundMatch !== void 0 && preferred.some((entry) => entry.profileId === boundMatch.profileId)) return boundMatch.profileId;
+		if (preferred.length === 1) return preferred[0].profileId;
+		if (preferred.length > 1) return fallback;
+		if (boundMatch !== void 0 && !boundMatch.profileId.startsWith("session:")) return boundMatch.profileId;
+		if (stableMatches.length === 1) return stableMatches[0].profileId;
+		if (stableMatches.length > 1) return fallback;
+		if (boundMatch !== void 0) return boundMatch.profileId;
+		return matches.length === 1 ? matches[0].profileId : fallback;
+	};
+	const reconcileStableProfile = async (sessionId, connection) => {
+		if (persistence === void 0 || connection.profileId === void 0) return connection;
+		const matches = matchingProfiles(connection);
+		const preferred = preferredMatches(matches);
+		if (preferred.some((entry) => entry.profileId === connection.profileId)) return connection;
+		const stableMatches = matches.filter((entry) => !entry.profileId.startsWith("session:"));
+		const target = preferred.length === 1 ? preferred[0] : connection.profileId.startsWith("session:") ? stableMatches.length === 1 ? stableMatches[0] : void 0 : void 0;
+		if (target === void 0) return connection;
+		const profileId = target.profileId;
+		const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		await persistence.putBinding(sessionId, {
+			profileId,
+			updatedAt
+		});
+		const reconciled = {
+			...connection,
+			profileId,
+			tables: copyTables(connection.tables)
+		};
+		runtime.set(sessionId, reconciled);
+		return reconciled;
+	};
 	const credentialSummary = async (connection) => {
 		const mode = credentialModeOf(connection);
 		if (connection.type === "sqlite" || mode === "none") return void 0;
@@ -2095,14 +2278,14 @@ function createConnectionService(ctx, options, persistence) {
 		async status(sessionId) {
 			const connection = rawConnection(sessionId);
 			if (connection === void 0) return void 0;
-			return statusSummary(connection);
+			return statusSummary(await reconcileStableProfile(sessionId, connection));
 		},
 		async connect(sessionId, input, signal) {
 			if (sessionId.length === 0) throw new Error("sessionId 必须是非空字符串");
 			const normalized = normalizeConnectionInput(input, resolvedOptions.cwd);
 			const execution = await resolveCredential(normalized);
 			const tables = await verify(execution, signal, true);
-			const profileId = normalized.profileId ?? `session:${sessionId}`;
+			const profileId = reusableProfileId(sessionId, normalized);
 			const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
 			const draft = formDraftFromConnection(normalized);
 			await persistAtomically(sessionId, profileId, profileFromConnection(normalized, updatedAt), draft);
@@ -2141,6 +2324,20 @@ function createConnectionService(ctx, options, persistence) {
 			if (connection === void 0) throw new Error("请先在 Web「数据库」标签页连接数据库，或在 TUI 运行 /database connect（未找到当前会话的连接）");
 			return resolveCredential(connection);
 		},
+		async queryMetadata(sessionId, sql, signal) {
+			if (sql.trim().length === 0) throw new Error("Catalog metadata SQL must not be empty");
+			const maxQueryChars = resolvedOptions.maxQueryChars ?? 65536;
+			if (sql.length > maxQueryChars) throw new Error(`Catalog metadata SQL exceeds ${maxQueryChars} characters`);
+			assertSingleStatement(sql, "Catalog metadata query");
+			const connection = await service.resolveForExecution(sessionId);
+			if (classifyStatement(sql, connection.type) !== "read") throw new Error("Catalog metadata execution accepts read-only system catalog statements only");
+			const result = await run(connection, sql, signal, true, false, void 0, resolvedOptions.catalogMaxResultChars ?? resolvedOptions.maxResultChars, true);
+			if (result.exitCode !== 0) {
+				const detail = result.stderr.trim() !== "" ? result.stderr.trim() : result.stdout.trim();
+				throw new Error(`Catalog metadata query failed (exit ${result.exitCode}): ${detail}`);
+			}
+			return result;
+		},
 		async listSchemas(sessionId, signal) {
 			const connection = await service.resolveForExecution(sessionId);
 			const stdout = await runMetadata(connection, "schemas", signal);
@@ -2182,7 +2379,7 @@ function createConnectionService(ctx, options, persistence) {
 				kind: "message",
 				...await run(connection, sql, signal)
 			};
-			const limitedSql = enforceReadRowLimit(sql, connection.type, WORKBENCH_MAX_EXPORT_ROWS + 1);
+			const limitedSql = enforceReadRowLimit(sql, connection.type, 50001);
 			const startedAt = Date.now();
 			const result = await run(connection, limitedSql, signal, false, false, "structured", WORKBENCH_MAX_RESULT_CHARS);
 			if (result.exitCode !== 0) return {
@@ -2294,6 +2491,23 @@ function profileFromConnection(connection, updatedAt) {
 		...connection.credentialMode !== void 0 ? { credentialMode: connection.credentialMode } : {}
 	};
 }
+/** Match only normalized, non-secret endpoint/principal identity fields. */
+function profileMatchesConnection(profile, connection, cwd = process.cwd()) {
+	let candidate;
+	try {
+		candidate = normalizeConnectionInput({
+			type: profile.type,
+			database: profile.database,
+			...profile.host !== void 0 ? { host: profile.host } : {},
+			...profile.port !== void 0 ? { port: profile.port } : {},
+			...profile.user !== void 0 ? { user: profile.user } : {},
+			...profile.secure !== void 0 ? { secure: profile.secure } : {}
+		}, cwd);
+	} catch {
+		return false;
+	}
+	return candidate.type === connection.type && candidate.database === connection.database && candidate.host === connection.host && candidate.port === connection.port && candidate.user === connection.user && (candidate.secure ?? false) === (connection.secure ?? false);
+}
 /** Infer legacy records while leaving ambiguous secret-less SQL profiles conservative. */
 function credentialModeOf(connection) {
 	if (connection.credentialMode !== void 0) return connection.credentialMode;
@@ -2308,4 +2522,4 @@ function requireIdentifier(type, value, label) {
 	return value;
 }
 //#endregion
-export { parseStructuredQueryOutput as a, clientsSchema as c, validatePasswordRef as i, enforceReadRowLimit as l, redactQueryResult as n, runClientQuery as o, redactSecretText as r, classifyStatement as s, createConnectionService as t, assertSingleStatement as u };
+export { isDatabaseType as C, defaultDatabasePort as S, clientsSchema as _, parseStructuredQueryOutput as a, DATABASE_TYPES as b, DEFAULT_CATALOG_MAX_RESULT_CHARS as c, DEFAULT_CONNECT_TIMEOUT_MS as d, DEFAULT_MAX_QUERY_CHARS as f, classifyStatement as g, DEFAULT_QUERY_TIMEOUT_MS as h, validatePasswordRef as i, DEFAULT_CATALOG_MAX_TEXT_CHARS as l, DEFAULT_PRESET_ID as m, redactQueryResult as n, runClientQuery as o, DEFAULT_MAX_RESULT_CHARS as p, redactSecretText as r, DEFAULT_CATALOG_MAX_ASSETS as s, createConnectionService as t, DEFAULT_CATALOG_QUERY_TIMEOUT_MS as u, enforceReadRowLimit as v, databaseTypeLabel as x, assertSingleStatement as y };