@yejiming/dsh-data-agent 0.0.2 → 0.0.5

package/lib/{defaults-Dgu2B2Yq.js → defaults-Bac6QvNt.js}

@@ -1,4 +1,322 @@
 import z from "schemastery";
+//#region src/sql.ts
+/**
+* Lightweight SQL-text scanning helpers shared by the sqlcmd tool half and
+* the /query route. This is intentionally NOT a SQL parser: the scanner only
+* understands lexical boundaries (strings, quoted identifiers, comments and
+* parenthesis depth) well enough to make the two agent-loop guarantees from
+* docs/optimization-opportunities.md:
+*
+* - a single tool call carries at most ONE SQL statement;
+* - `maxRows` can be enforced with a real top-level LIMIT, not just a prompt.
+*
+* @module @yejiming/dsh-data-agent/sql
+*/
+const IDENT_CHAR = /[A-Za-z0-9_$]/;
+function isWhitespace(char) {
+	return /\s/.test(char);
+}
+function isIdentChar(char) {
+	return IDENT_CHAR.test(char);
+}
+function skipQuoted(sql, start) {
+	const quote = sql[start];
+	let index = start + 1;
+	while (index < sql.length) {
+		const char = sql[index];
+		if (char === "\\" && index + 1 < sql.length && quote !== "`") {
+			index += 2;
+			continue;
+		}
+		if (char === quote) {
+			if (sql[index + 1] === quote) {
+				index += 2;
+				continue;
+			}
+			return index + 1;
+		}
+		index += 1;
+	}
+	return sql.length;
+}
+function skipDollarQuoted(sql, start) {
+	const match = sql.slice(start).match(/^\$[A-Za-z_][A-Za-z0-9_]*\$|^\$\$/);
+	if (match === null) return -1;
+	const delimiter = match[0];
+	const end = sql.indexOf(delimiter, start + delimiter.length);
+	return end === -1 ? sql.length : end + delimiter.length;
+}
+function skipOracleQuoted(sql, start) {
+	if (!/^q'/i.test(sql.slice(start, start + 2))) return -1;
+	const open = sql[start + 2];
+	if (open === void 0) return sql.length;
+	const close = {
+		"[": "]",
+		"{": "}",
+		"(": ")",
+		"<": ">"
+	}[open] ?? open;
+	let index = start + 3;
+	while (index < sql.length) {
+		if (sql[index] === close && sql[index + 1] === "'") return index + 2;
+		index += 1;
+	}
+	return sql.length;
+}
+function skipBlockComment(sql, start) {
+	let depth = 1;
+	let index = start + 2;
+	while (index < sql.length) {
+		if (sql.startsWith("/*", index)) {
+			depth += 1;
+			index += 2;
+			continue;
+		}
+		if (sql.startsWith("*/", index)) {
+			depth -= 1;
+			index += 2;
+			if (depth === 0) return index;
+			continue;
+		}
+		index += 1;
+	}
+	return sql.length;
+}
+function skipLineComment(sql, start) {
+	const newline = sql.indexOf("\n", start);
+	return newline === -1 ? sql.length : newline + 1;
+}
+/**
+* Walk the SQL text, invoking `onSemicolon` for every top-level statement
+* separator (parenthesis depth zero, outside strings, quoted identifiers and
+* comments).
+*/
+function scanTopLevelSemicolons(sql, onSemicolon) {
+	let depth = 0;
+	let index = 0;
+	while (index < sql.length) {
+		const char = sql[index];
+		if (isWhitespace(char)) {
+			index += 1;
+			continue;
+		}
+		if (sql.startsWith("--", index)) {
+			index = skipLineComment(sql, index + 2);
+			continue;
+		}
+		if (sql.startsWith("/*", index)) {
+			index = skipBlockComment(sql, index);
+			continue;
+		}
+		if (char === "'" || char === "\"" || char === "`") {
+			index = skipQuoted(sql, index);
+			continue;
+		}
+		if (char === "$") {
+			const dollarEnd = skipDollarQuoted(sql, index);
+			if (dollarEnd !== -1) {
+				index = dollarEnd;
+				continue;
+			}
+		}
+		const oracleEnd = skipOracleQuoted(sql, index);
+		if (oracleEnd !== -1) {
+			index = oracleEnd;
+			continue;
+		}
+		if (char === "(") {
+			depth += 1;
+			index += 1;
+			continue;
+		}
+		if (char === ")") {
+			depth = Math.max(0, depth - 1);
+			index += 1;
+			continue;
+		}
+		if (char === ";" && depth === 0) onSemicolon(index);
+		index += 1;
+	}
+}
+/** Whether meaningful SQL content exists after `index` (trailing `;`/comments ignored). */
+function hasContentAfter(sql, index) {
+	let cursor = index;
+	while (cursor < sql.length) {
+		const char = sql[cursor];
+		if (isWhitespace(char)) {
+			cursor += 1;
+			continue;
+		}
+		if (char === ";") {
+			cursor += 1;
+			continue;
+		}
+		if (sql.startsWith("--", cursor)) {
+			cursor = skipLineComment(sql, cursor + 2);
+			continue;
+		}
+		if (sql.startsWith("/*", cursor)) {
+			cursor = skipBlockComment(sql, cursor);
+			continue;
+		}
+		return true;
+	}
+	return false;
+}
+/**
+* Throw unless `sql` contains at most one statement. A single trailing
+* semicolon (and any number of repeated trailing semicolons / comments) is
+* accepted; a semicolon followed by real content is rejected.
+*/
+function assertSingleStatement(sql, label = "SQL") {
+	if (stripTrailingTerminator(sql).trim().length === 0) throw new Error(`${label}: SQL 不能为空`);
+	const semicolons = [];
+	scanTopLevelSemicolons(sql, (index) => {
+		semicolons.push(index);
+	});
+	const offending = semicolons.find((index) => hasContentAfter(sql, index + 1));
+	if (offending === void 0) return;
+	throw new Error(`${label}: 一次只允许执行一条 SQL 语句（第 ${offending + 1} 个字符后的分号不是末尾分号）。多条语句请拆成多次调用；客户端进程独立、自动提交，不支持在多次调用间保持事务。`);
+}
+/** Whether `keyword` appears at top level as a whole word in `sql`. */
+function hasTopLevelKeyword(sql, keyword) {
+	const needle = keyword.toLowerCase();
+	let depth = 0;
+	let index = 0;
+	while (index < sql.length) {
+		const char = sql[index];
+		if (isWhitespace(char)) {
+			index += 1;
+			continue;
+		}
+		if (sql.startsWith("--", index)) {
+			index = skipLineComment(sql, index + 2);
+			continue;
+		}
+		if (sql.startsWith("/*", index)) {
+			index = skipBlockComment(sql, index);
+			continue;
+		}
+		if (char === "'" || char === "\"" || char === "`") {
+			index = skipQuoted(sql, index);
+			continue;
+		}
+		if (char === "$") {
+			const dollarEnd = skipDollarQuoted(sql, index);
+			if (dollarEnd !== -1) {
+				index = dollarEnd;
+				continue;
+			}
+		}
+		const oracleEnd = skipOracleQuoted(sql, index);
+		if (oracleEnd !== -1) {
+			index = oracleEnd;
+			continue;
+		}
+		if (char === "(") {
+			depth += 1;
+			index += 1;
+			continue;
+		}
+		if (char === ")") {
+			depth = Math.max(0, depth - 1);
+			index += 1;
+			continue;
+		}
+		if (depth === 0 && sql.slice(index, index + needle.length).toLowerCase() === needle && (index === 0 || !isIdentChar(sql[index - 1])) && (index + needle.length >= sql.length || !isIdentChar(sql[index + needle.length]))) return true;
+		index += 1;
+	}
+	return false;
+}
+function trailingLineCommentStart(sql, end) {
+	let index = sql.lastIndexOf("\n", end - 1) + 1;
+	while (index < end) {
+		const char = sql[index];
+		if (char === "'" || char === "\"" || char === "`") {
+			index = skipQuoted(sql, index);
+			continue;
+		}
+		if (sql.startsWith("--", index)) {
+			const tail = sql.slice(index + 2, end);
+			return tail.length === 0 || isWhitespace(tail[0]) ? index : -1;
+		}
+		index += 1;
+	}
+	return -1;
+}
+function blockCommentEndingAt(sql, end) {
+	let candidate = -1;
+	let index = 0;
+	while (index < end) {
+		const char = sql[index];
+		if (isWhitespace(char)) {
+			index += 1;
+			continue;
+		}
+		if (char === "'" || char === "\"" || char === "`") {
+			index = skipQuoted(sql, index);
+			continue;
+		}
+		if (sql.startsWith("--", index)) {
+			index = skipLineComment(sql, index + 2);
+			continue;
+		}
+		if (sql.startsWith("/*", index)) {
+			const start = index;
+			let commentDepth = 1;
+			index += 2;
+			while (index < end && commentDepth > 0) {
+				if (sql.startsWith("/*", index)) {
+					commentDepth += 1;
+					index += 2;
+					continue;
+				}
+				if (sql.startsWith("*/", index)) {
+					commentDepth -= 1;
+					index += 2;
+					if (commentDepth === 0) {
+						if (index === end) candidate = start;
+						break;
+					}
+					continue;
+				}
+				index += 1;
+			}
+			continue;
+		}
+		index += 1;
+	}
+	return candidate;
+}
+/**
+* Strip trailing whitespace, statement terminators and trailing comments so a
+* limit clause can be appended to the actual statement text. Only comments
+* that occupy the whole tail are removed; the preceding statement is kept.
+*/
+function stripTrailingTerminator(sql) {
+	let end = sql.length;
+	for (;;) {
+		while (end > 0 && isWhitespace(sql[end - 1])) end -= 1;
+		if (end > 0 && sql[end - 1] === ";") {
+			end -= 1;
+			continue;
+		}
+		if (end >= 2 && sql.slice(end - 2, end) === "*/") {
+			const start = blockCommentEndingAt(sql, end);
+			if (start !== -1) {
+				end = start;
+				continue;
+			}
+		}
+		const lineComment = trailingLineCommentStart(sql, end);
+		if (lineComment !== -1) {
+			end = lineComment;
+			continue;
+		}
+		return sql.slice(0, end);
+	}
+}
+//#endregion
 //#region src/clients.ts
 /**
 * Whitespace / comment stripping for {@link classifyStatement}: remove
@@ -119,7 +437,8 @@ function skipParens(sql, start) {
 /**
 * Classify a SQL text as a read or write statement by its FIRST effective
 * token (a conservative read whitelist, not a parser). `with` is read only
-* when its body's first token is `select`. `pragma` is read-only for SQLite.
+* when its body's first token is `select`. SQLite `pragma` is read in its
+* query form and write when a value is assigned.
 */
 function classifyStatement(sql, type) {
 	const rest = stripLeadingComments(sql);
@@ -131,12 +450,116 @@ function classifyStatement(sql, type) {
 		case "describe":
 		case "desc":
 		case "explain": return "read";
-		case "pragma": return type === "sqlite" ? "read" : "write";
+		case "pragma": {
+			if (type !== "sqlite") return "write";
+			const afterPragma = rest.replace(/^pragma\b/i, "").trimStart();
+			return /^(?:[A-Za-z_][A-Za-z0-9_$]*(?:\s*\.\s*[A-Za-z_][A-Za-z0-9_$]*)?|"[^"]+"|`[^`]+`)\s*=/.test(afterPragma) ? "write" : "read";
+		}
 		case "with": return stripWithBody(rest).match(/^[A-Za-z_]+/)?.[0]?.toLowerCase() === "select" ? "read" : "write";
 		default: return "write";
 	}
 }
 /**
+* Enforce the configured `maxRows` on a read query instead of relying on the
+* prompt. SELECT/CTE-read statements get a real top-level LIMIT (Oracle uses
+* a ROWNUM wrapper because it has no LIMIT); SHOW/DESCRIBE/EXPLAIN/PRAGMA are
+* left untouched here and are capped while parsing structured output.
+*
+* An existing numeric top-level LIMIT is rewritten when it is larger than
+* `maxRows`; a smaller existing LIMIT is preserved, and a non-numeric or
+* unparseable LIMIT is left for the client (structured tools still truncate).
+*/
+function enforceReadRowLimit(sql, type, maxRows) {
+	if (classifyStatement(sql, type) !== "read") return sql;
+	const first = stripLeadingComments(sql).match(/^[A-Za-z_]+/)?.[0]?.toLowerCase();
+	if (first !== "select" && first !== "with") return sql;
+	const hadTrailingSemicolon = /;\s*$/.test(sql);
+	if (!hasTopLevelKeyword(sql, "limit") && type !== "oracle") return `${stripTrailingTerminator(sql)} LIMIT ${maxRows}${hadTrailingSemicolon ? ";" : ""}`;
+	if (type === "oracle") return `SELECT * FROM (${stripTrailingTerminator(sql)}) dsh_limit WHERE ROWNUM <= ${maxRows}${hadTrailingSemicolon ? ";" : ""}`;
+	if (!hasTopLevelKeyword(sql, "limit")) return sql;
+	return rewriteTopLevelLimit(sql, maxRows);
+}
+/** Rewrite the first top-level `LIMIT n` / `LIMIT n, m` with a capped row count. */
+function rewriteTopLevelLimit(sql, maxRows) {
+	let depth = 0;
+	let index = 0;
+	while (index < sql.length) {
+		const char = sql[index];
+		if (/\s/.test(char)) {
+			index += 1;
+			continue;
+		}
+		if (sql.startsWith("--", index)) {
+			const newline = sql.indexOf("\n", index + 2);
+			index = newline === -1 ? sql.length : newline + 1;
+			continue;
+		}
+		if (sql.startsWith("/*", index)) {
+			let depthComment = 1;
+			index += 2;
+			while (index < sql.length && depthComment > 0) {
+				if (sql.startsWith("/*", index)) {
+					depthComment += 1;
+					index += 2;
+					continue;
+				}
+				if (sql.startsWith("*/", index)) {
+					depthComment -= 1;
+					index += 2;
+					continue;
+				}
+				index += 1;
+			}
+			continue;
+		}
+		if (char === "'" || char === "\"" || char === "`") {
+			const quote = char;
+			index += 1;
+			while (index < sql.length) {
+				if (sql[index] === "\\" && index + 1 < sql.length && quote !== "`") {
+					index += 2;
+					continue;
+				}
+				if (sql[index] === quote) {
+					if (sql[index + 1] === quote) {
+						index += 2;
+						continue;
+					}
+					index += 1;
+					break;
+				}
+				index += 1;
+			}
+			continue;
+		}
+		if (char === "(") {
+			depth += 1;
+			index += 1;
+			continue;
+		}
+		if (char === ")") {
+			depth = Math.max(0, depth - 1);
+			index += 1;
+			continue;
+		}
+		if (depth === 0 && sql.slice(index, index + 5).toLowerCase() === "limit" && (index === 0 || !/[A-Za-z0-9_$]/.test(sql[index - 1])) && (index + 5 >= sql.length || !/[A-Za-z0-9_$]/.test(sql[index + 5]))) {
+			const match = sql.slice(index).match(/^LIMIT\s+(ALL|\d+)(\s*,\s*\d+)?/i);
+			if (match === null) return sql;
+			const firstValue = match[1];
+			const hasOffsetPart = match[2] !== void 0;
+			let replacement = "";
+			if (hasOffsetPart) {
+				const rowCount = Number(match[2].match(/\d+/)[0]);
+				replacement = `LIMIT ${firstValue === "ALL" ? "0" : firstValue}, ${Math.min(rowCount, maxRows)}`;
+			} else if (/^\d+$/.test(firstValue)) replacement = `LIMIT ${Math.min(Number(firstValue), maxRows)}`;
+			else replacement = `LIMIT ${maxRows}`;
+			return sql.slice(0, index) + replacement + sql.slice(index + match[0].length);
+		}
+		index += 1;
+	}
+	return sql;
+}
+/**
 * Validate and quote one schema/table identifier for a safe metadata query.
 * Identifiers are restricted to `[A-Za-z0-9_$]+` and then wrapped per type:
 * backticks (mysql/hive/impala) or double quotes (postgres/oracle/sqlite),
@@ -191,6 +614,15 @@ const INTROSPECT_ARGS = {
 	hive: ["--silent=true", "--outputformat=tsv2"],
 	impala: ["-B"]
 };
+/** Structured `sql-query` flag arguments: header + one row per line. */
+const STRUCTURED_QUERY_ARGS = {
+	mysql: ["--batch", "--raw"],
+	postgres: ["-A"],
+	sqlite: ["-header", "-csv"],
+	oracle: ["-S", "/nolog"],
+	hive: ["--silent=true", "--outputformat=tsv2"],
+	impala: ["-B", "--print_header"]
+};
 /** Default ports when the connection does not carry one. */
 const DEFAULT_PORTS = {
 	mysql: 3306,
@@ -284,6 +716,23 @@ function stdinPrefix(type, connection) {
 		case "impala": return "";
 	}
 }
+/**
+* Oracle structured-query prefix: same connect block as {@link stdinPrefix},
+* but with HEADING ON and UNDERLINE OFF so `sql-query` can read the column
+* names from the first output line.
+*/
+function structuredStdinPrefix(type, connection) {
+	if (type !== "oracle") return stdinPrefix(type, connection);
+	return `${[
+		"SET PAGESIZE 0",
+		"SET FEEDBACK OFF",
+		"SET HEADING ON",
+		"SET UNDERLINE OFF",
+		"SET COLSEP '|'",
+		"SET TRIMSPOOL ON",
+		connection.user !== void 0 ? `connect ${connection.user}${connection.password !== void 0 ? `/${connection.password}` : ""}@${connection.host ?? "127.0.0.1"}:${connection.port ?? DEFAULT_PORTS.oracle}/${connection.database}` : ""
+	].filter((line) => line !== "").join("\n")}\n`;
+}
 /** Apply one deployment override's extra args in front of the built-in flags. */
 function withOverrides(flags, override) {
 	if (override === void 0 || override.args === void 0) return flags;
@@ -312,6 +761,19 @@ function buildIntrospectTemplate(type, connection, override) {
 	};
 }
 /**
+* Build one client invocation for the structured `sql-query` tool: every
+* supported client prints a header row followed by one row per line (mysql
+* tab, postgres pipe, sqlite csv, oracle pipe, hive/impala tsv).
+*/
+function buildStructuredQueryTemplate(type, connection, override) {
+	return {
+		command: override?.command ?? DEFAULT_CLIENTS_COMMAND[type],
+		args: [...withOverrides(STRUCTURED_QUERY_ARGS[type], override), ...connectionArgs(type, connection)],
+		env: credentialEnv(type, connection),
+		stdinPrefix: structuredStdinPrefix(type, connection)
+	};
+}
+/**
 * The table-listing SQL per type, run at /connect time to verify
 * connectivity: the connected database's own tables (mysql uses the
 * connection's database as the schema; postgres lists `public`; oracle lists
@@ -329,7 +791,7 @@ function tableListingSql(type, connection) {
 }
 /**
 * Metadata query per kind × type. `schema`/`table` are identifier whitelist
-* validated by the caller (`[A-Za-z0-9_$#.-]`) before they reach here.
+* validated by the caller (`[A-Za-z0-9_$]`) before they reach here.
 */
 function metadataQuery(kind, type, schema, table) {
 	switch (kind) {
@@ -429,7 +891,7 @@ function parseColumns(type, stdout) {
 //#region src/defaults.ts
 /**
 * Package-wide defaults shared by the server half (`src/index.ts`) and the
-* sqlcmd tool half (`src/tool.ts`). Loader schemas carry these as their
+* 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
 */
@@ -437,13 +899,13 @@ function parseColumns(type, stdout) {
 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 sqlcmd query, milliseconds. */
+/** End-to-end deadline for one database-tool query, milliseconds. */
 const DEFAULT_QUERY_TIMEOUT_MS = 3e4;
-/** In-memory cap on sqlcmd captured output (stdout and stderr each). */
+/** In-memory cap on database-tool captured output (stdout and stderr each). */
 const DEFAULT_MAX_RESULT_CHARS = 2e4;
 /** Cap on one /query SQL text length (abuse guard; the wire body stays small). */
 const DEFAULT_MAX_QUERY_CHARS = 65536;
 /** Grace period for the subprocess terminate escalation. */
 const DEFAULT_GRACE_MS = 5e3;
 //#endregion
-export { DEFAULT_PRESET_ID as a, buildIntrospectTemplate as c, metadataQuery as d, parseColumns as f, tableListingSql as g, sanitizeIdentifier as h, DEFAULT_MAX_RESULT_CHARS as i, classifyStatement as l, parseTableListing as m, DEFAULT_GRACE_MS as n, DEFAULT_QUERY_TIMEOUT_MS as o, parseListing as p, DEFAULT_MAX_QUERY_CHARS as r, buildClientTemplate as s, DEFAULT_CONNECT_TIMEOUT_MS as t, clientsSchema as u };
+export { sanitizeIdentifier as _, DEFAULT_PRESET_ID as a, buildIntrospectTemplate as c, clientsSchema as d, enforceReadRowLimit as f, parseTableListing as g, parseListing as h, DEFAULT_MAX_RESULT_CHARS as i, buildStructuredQueryTemplate as l, parseColumns as m, DEFAULT_GRACE_MS as n, DEFAULT_QUERY_TIMEOUT_MS as o, metadataQuery as p, DEFAULT_MAX_QUERY_CHARS as r, buildClientTemplate as s, DEFAULT_CONNECT_TIMEOUT_MS as t, classifyStatement as u, tableListingSql as v, assertSingleStatement as y };

package/lib/index.js

@@ -1,4 +1,4 @@
-import { a as DEFAULT_PRESET_ID, i as DEFAULT_MAX_RESULT_CHARS, o as DEFAULT_QUERY_TIMEOUT_MS, t as DEFAULT_CONNECT_TIMEOUT_MS, u as clientsSchema } from "./defaults-Dgu2B2Yq.js";
+import { a as DEFAULT_PRESET_ID, d as clientsSchema, i as DEFAULT_MAX_RESULT_CHARS, o as DEFAULT_QUERY_TIMEOUT_MS, t as DEFAULT_CONNECT_TIMEOUT_MS } from "./defaults-Bac6QvNt.js";
 import { access, cp, mkdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
@@ -53,9 +53,9 @@ function createConnectionStore() {
 *
 * The HTTP routes live in the separate `./routes` entry
 * (`@yejiming/dsh-data-agent/routes`, cordis row `data-agent-routes`) so
-* this row keeps working in headless profiles without a webserver; the sqlcmd
-* tool itself lives in the `./tool` entry and is mounted only by the
-* data-agent preset.
+* this row keeps working in headless profiles without a webserver; the
+* database tools themselves live in the `./tool` entry and are mounted only
+* by the data-agent preset.
 * @module @yejiming/dsh-data-agent
 */
 /** Cordis plugin name (diagnostics only). */

package/lib/{query-vK9dr7Z6.js → query-CmhTFklw.js}

@@ -1,4 +1,4 @@
-import { c as buildIntrospectTemplate, s as buildClientTemplate } from "./defaults-Dgu2B2Yq.js";
+import { c as buildIntrospectTemplate, l as buildStructuredQueryTemplate, s as buildClientTemplate } from "./defaults-Bac6QvNt.js";
 //#region src/query.ts
 /** Read one collected stream from offset 0. */
 function readCaptured(reader) {
@@ -33,7 +33,7 @@ function readCaptured(reader) {
 * @returns the captured outcome.
 */
 async function runClientQuery(ctx, connection, sql, options, externalSignal, introspect = false) {
-	const template = introspect ? buildIntrospectTemplate(connection.type, connection, options.clients[connection.type]) : buildClientTemplate(connection.type, connection, options.clients[connection.type]);
+	const template = options.mode === "structured" ? buildStructuredQueryTemplate(connection.type, connection, options.clients[connection.type]) : options.mode === "introspect" || introspect ? buildIntrospectTemplate(connection.type, connection, options.clients[connection.type]) : buildClientTemplate(connection.type, connection, options.clients[connection.type]);
 	const controller = new AbortController();
 	const timer = setTimeout(() => controller.abort(/* @__PURE__ */ new Error(`查询超过 ${options.timeoutMs}ms 未完成，已终止客户端进程`)), options.timeoutMs);
 	const onExternalAbort = () => {

package/lib/routes.js

@@ -1,5 +1,5 @@
-import { d as metadataQuery, f as parseColumns, g as tableListingSql, h as sanitizeIdentifier, i as DEFAULT_MAX_RESULT_CHARS, l as classifyStatement, m as parseTableListing, o as DEFAULT_QUERY_TIMEOUT_MS, p as parseListing, r as DEFAULT_MAX_QUERY_CHARS, t as DEFAULT_CONNECT_TIMEOUT_MS } from "./defaults-Dgu2B2Yq.js";
-import { t as runClientQuery } from "./query-vK9dr7Z6.js";
+import { _ as sanitizeIdentifier, g as parseTableListing, h as parseListing, i as DEFAULT_MAX_RESULT_CHARS, m as parseColumns, o as DEFAULT_QUERY_TIMEOUT_MS, p as metadataQuery, r as DEFAULT_MAX_QUERY_CHARS, t as DEFAULT_CONNECT_TIMEOUT_MS, u as classifyStatement, v as tableListingSql, y as assertSingleStatement } from "./defaults-Bac6QvNt.js";
+import { t as runClientQuery } from "./query-CmhTFklw.js";
 import { resolve } from "node:path";
 import z from "schemastery";
 //#region src/routes.ts
@@ -231,6 +231,7 @@ function apply(ctx, config) {
 							const sql = body.sql;
 							if (typeof sql !== "string" || sql.trim().length === 0) throw new Error("sql 必须是非空字符串");
 							if (sql.length > config.maxQueryChars) throw new Error(`sql 超过长度上限（${config.maxQueryChars} 字符）`);
+							assertSingleStatement(sql, "/query");
 							const connection = requireConnection(sessionId);
 							if ((connection.readonly ?? config.readonly) && classifyStatement(sql, connection.type) === "write") throw new Error("当前连接为只读模式，拒绝执行非读语句（仅放行 SELECT/SHOW/DESCRIBE/EXPLAIN/PRAGMA 等）");
 							writeJson(200, {