@eamonboyle/mssql-mcp 1.5.0 → 2.0.0

package/dist/apps/queryResultsApp.d.ts

@@ -0,0 +1,18 @@
+import type { McpServer } from "@modelcontextprotocol/server";
+/**
+ * MCP Apps (io.modelcontextprotocol/ui) view that renders read_data and
+ * search_data results as an interactive grid in hosts that support it
+ * (Claude, VS Code, Cursor, …). Hosts without MCP Apps ignore the tool
+ * metadata and keep using the text/structured result.
+ */
+export declare const QUERY_RESULTS_APP_URI = "ui://mssql/query-results.html";
+export declare function buildQueryResultsHtml(): string;
+export declare function registerQueryResultsApp(server: McpServer): void;
+/** Tool `_meta` linking a tool to the query-results view (both key styles). */
+export declare const queryResultsToolMeta: {
+    ui: {
+        resourceUri: string;
+    };
+    "ui/resourceUri": string;
+};
+//# sourceMappingURL=queryResultsApp.d.ts.map

package/dist/apps/queryResultsApp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryResultsApp.d.ts","sourceRoot":"","sources":["../../src/apps/queryResultsApp.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAE9D;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,kCAAkC,CAAC;AAqOrE,wBAAgB,qBAAqB,IAAI,MAAM,CAmB9C;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAuB/D;AAED,+EAA+E;AAC/E,eAAO,MAAM,oBAAoB;;;;;CAGhC,CAAC"}

package/dist/apps/queryResultsApp.js

@@ -0,0 +1,272 @@
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { RESOURCE_MIME_TYPE, registerAppResource, } from "@modelcontextprotocol/ext-apps/server";
+/**
+ * MCP Apps (io.modelcontextprotocol/ui) view that renders read_data and
+ * search_data results as an interactive grid in hosts that support it
+ * (Claude, VS Code, Cursor, …). Hosts without MCP Apps ignore the tool
+ * metadata and keep using the text/structured result.
+ */
+export const QUERY_RESULTS_APP_URI = "ui://mssql/query-results.html";
+const require = createRequire(import.meta.url);
+/**
+ * Loads the self-contained ext-apps View runtime and rewrites its trailing
+ * `export{…}` into a local binding so it can be inlined into a single
+ * module script (hosts render the view from one HTML document).
+ */
+function loadAppRuntime() {
+    const bundle = readFileSync(require.resolve("@modelcontextprotocol/ext-apps/app-with-deps"), "utf8");
+    const exportStart = bundle.lastIndexOf("export{");
+    if (exportStart === -1) {
+        throw new Error("Unexpected ext-apps bundle format: missing export list.");
+    }
+    const exportEnd = bundle.indexOf("}", exportStart);
+    const entries = bundle
+        .slice(exportStart + "export{".length, exportEnd)
+        .split(",")
+        .map((entry) => {
+        const [local, exported = local] = entry.trim().split(/\s+as\s+/);
+        return `${JSON.stringify(exported)}:${local}`;
+    });
+    return `${bundle.slice(0, exportStart)}const ExtApps={${entries.join(",")}};${bundle.slice(exportEnd + 1)}`;
+}
+const VIEW_STYLES = `
+:root { color-scheme: light dark; }
+* { box-sizing: border-box; }
+body {
+  margin: 0;
+  font-family: var(--font-sans, system-ui, sans-serif);
+  font-size: var(--font-text-sm-size, 13px);
+  color: var(--color-text-primary, CanvasText);
+  background: var(--color-background-primary, Canvas);
+}
+header {
+  display: flex; gap: 8px; align-items: center; flex-wrap: wrap;
+  padding: 8px 10px;
+  border-bottom: 1px solid var(--color-border-primary, #8884);
+}
+header .summary { flex: 1; color: var(--color-text-secondary, GrayText); }
+.badge {
+  padding: 1px 6px; border-radius: 999px; font-size: 11px;
+  background: var(--color-background-warning, #f5a62333);
+  color: var(--color-text-warning, inherit);
+}
+input[type="search"] {
+  font: inherit; padding: 3px 8px; min-width: 160px;
+  color: inherit; background: transparent;
+  border: 1px solid var(--color-border-primary, #8886);
+  border-radius: var(--border-radius-sm, 4px);
+}
+.grid { overflow: auto; max-height: 480px; }
+table { border-collapse: collapse; width: 100%; font-variant-numeric: tabular-nums; }
+th, td {
+  padding: 4px 10px; text-align: left; white-space: nowrap;
+  border-bottom: 1px solid var(--color-border-secondary, #8882);
+  max-width: 360px; overflow: hidden; text-overflow: ellipsis;
+}
+th {
+  position: sticky; top: 0; cursor: pointer; user-select: none;
+  background: var(--color-background-secondary, Canvas);
+  font-weight: 600;
+}
+th[aria-sort="ascending"]::after { content: " ▲"; }
+th[aria-sort="descending"]::after { content: " ▼"; }
+td.null { color: var(--color-text-tertiary, GrayText); font-style: italic; }
+td.num { text-align: right; }
+.empty, .error { padding: 16px 10px; color: var(--color-text-secondary, GrayText); }
+.error { color: var(--color-text-danger, #d33); }
+`;
+const VIEW_SCRIPT = `
+const { App, applyDocumentTheme, applyHostStyleVariables, applyHostFonts } = ExtApps;
+const MAX_RENDERED_ROWS = 1000;
+const root = document.getElementById("root");
+let rows = [];
+let columns = [];
+let meta = {};
+let sort = { column: null, direction: 1 };
+let filter = "";
+
+function extractRows(payload) {
+  const data = payload && payload.data;
+  if (Array.isArray(data)) return data;
+  if (data && Array.isArray(data.rows)) return data.rows;
+  if (data && Array.isArray(data.data)) return data.data;
+  return [];
+}
+
+function formatCell(value) {
+  if (value === null || value === undefined) return { text: "NULL", cls: "null" };
+  if (typeof value === "number" || typeof value === "bigint") return { text: String(value), cls: "num" };
+  if (typeof value === "object") return { text: JSON.stringify(value), cls: "" };
+  return { text: String(value), cls: "" };
+}
+
+function el(tag, attrs, children) {
+  const node = document.createElement(tag);
+  for (const [key, value] of Object.entries(attrs || {})) {
+    if (key === "text") node.textContent = value;
+    else if (key.startsWith("on")) node.addEventListener(key.slice(2), value);
+    else node.setAttribute(key, value);
+  }
+  for (const child of children || []) node.append(child);
+  return node;
+}
+
+function visibleRows() {
+  let result = rows;
+  if (filter) {
+    const needle = filter.toLowerCase();
+    result = result.filter((row) =>
+      columns.some((column) => String(row[column] ?? "").toLowerCase().includes(needle))
+    );
+  }
+  if (sort.column !== null) {
+    const column = sort.column;
+    result = [...result].sort((a, b) => {
+      const left = a[column];
+      const right = b[column];
+      if (left === right) return 0;
+      if (left === null || left === undefined) return 1;
+      if (right === null || right === undefined) return -1;
+      return (left < right ? -1 : 1) * sort.direction;
+    });
+  }
+  return result;
+}
+
+function render() {
+  root.replaceChildren();
+  if (meta.error) {
+    root.append(el("div", { class: "error", text: meta.error }));
+    return;
+  }
+
+  const shown = visibleRows();
+  const rendered = shown.slice(0, MAX_RENDERED_ROWS);
+  const summaryParts = [rows.length + " row" + (rows.length === 1 ? "" : "s")];
+  if (filter) summaryParts.push(shown.length + " matching");
+  if (rendered.length < shown.length) summaryParts.push("showing first " + rendered.length);
+
+  const header = el("header", {}, [
+    el("span", { class: "summary", text: summaryParts.join(" · ") }),
+  ]);
+  if (meta.truncated) {
+    header.append(el("span", { class: "badge", text: "Truncated at MAX_ROWS", title: "More rows exist on the server" }));
+  }
+  header.append(
+    el("input", {
+      type: "search",
+      placeholder: "Filter rows",
+      value: filter,
+      "aria-label": "Filter rows",
+      oninput: (event) => {
+        filter = event.target.value;
+        render();
+        const input = root.querySelector("input[type=search]");
+        input.focus();
+        input.setSelectionRange(filter.length, filter.length);
+      },
+    })
+  );
+  root.append(header);
+
+  if (rows.length === 0) {
+    root.append(el("div", { class: "empty", text: meta.message || "No rows returned." }));
+    return;
+  }
+
+  const headRow = el("tr", {}, columns.map((column) => {
+    const ariaSort = sort.column === column ? (sort.direction === 1 ? "ascending" : "descending") : "none";
+    return el("th", {
+      text: column,
+      scope: "col",
+      "aria-sort": ariaSort,
+      onclick: () => {
+        sort = sort.column === column ? { column, direction: -sort.direction } : { column, direction: 1 };
+        render();
+      },
+    });
+  }));
+  const body = el("tbody", {}, rendered.map((row) =>
+    el("tr", {}, columns.map((column) => {
+      const cell = formatCell(row[column]);
+      return el("td", { class: cell.cls, text: cell.text, title: cell.text });
+    }))
+  ));
+  root.append(el("div", { class: "grid" }, [el("table", {}, [el("thead", {}, [headRow]), body])]));
+}
+
+function showResult(result) {
+  const payload = result && result.structuredContent;
+  if (!payload) {
+    meta = { error: "This result has no structured content to display." };
+  } else if (payload.success === false) {
+    meta = { error: payload.message || "The query failed." };
+  } else {
+    rows = extractRows(payload);
+    columns = rows.length > 0 ? Object.keys(rows[0]) : [];
+    meta = { truncated: payload.truncated === true, message: payload.message };
+  }
+  sort = { column: null, direction: 1 };
+  filter = "";
+  render();
+}
+
+function applyHostContext(context) {
+  if (!context) return;
+  if (context.theme) applyDocumentTheme(context.theme);
+  if (context.styles && context.styles.variables) applyHostStyleVariables(context.styles.variables);
+  if (context.styles && context.styles.css && context.styles.css.fonts) applyHostFonts(context.styles.css.fonts);
+}
+
+const app = new App({ name: "mssql-query-results", version: "1.0.0" }, {}, { autoResize: true });
+app.ontoolresult = showResult;
+app.onhostcontextchanged = applyHostContext;
+root.append(el("div", { class: "empty", text: "Waiting for query results…" }));
+await app.connect();
+applyHostContext(app.getHostContext());
+`;
+let cachedHtml;
+export function buildQueryResultsHtml() {
+    cachedHtml ??= `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Query results</title>
+<style>${VIEW_STYLES}</style>
+</head>
+<body>
+<div id="root"></div>
+<script type="module">
+${loadAppRuntime()}
+${VIEW_SCRIPT}
+</script>
+</body>
+</html>
+`;
+    return cachedHtml;
+}
+export function registerQueryResultsApp(server) {
+    registerAppResource(server, "query_results_app", QUERY_RESULTS_APP_URI, {
+        title: "Query Results Grid",
+        description: "Interactive, sortable and filterable grid for read_data and search_data results.",
+        mimeType: RESOURCE_MIME_TYPE,
+        _meta: { ui: { prefersBorder: true } },
+    }, async () => ({
+        contents: [
+            {
+                uri: QUERY_RESULTS_APP_URI,
+                mimeType: RESOURCE_MIME_TYPE,
+                text: buildQueryResultsHtml(),
+                _meta: { ui: { prefersBorder: true } },
+            },
+        ],
+    }));
+}
+/** Tool `_meta` linking a tool to the query-results view (both key styles). */
+export const queryResultsToolMeta = {
+    ui: { resourceUri: QUERY_RESULTS_APP_URI },
+    "ui/resourceUri": QUERY_RESULTS_APP_URI,
+};
+//# sourceMappingURL=queryResultsApp.js.map

package/dist/apps/queryResultsApp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryResultsApp.js","sourceRoot":"","sources":["../../src/apps/queryResultsApp.ts"],"names":[],"mappings":"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"}

package/dist/checkNodeVersion.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=checkNodeVersion.d.ts.map

package/dist/checkNodeVersion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkNodeVersion.d.ts","sourceRoot":"","sources":["../src/checkNodeVersion.ts"],"names":[],"mappings":""}

package/dist/checkNodeVersion.js

@@ -0,0 +1,9 @@
+// Imported first by index.ts so it runs before any dependency is evaluated.
+// Logs to stderr only: stdout belongs to the stdio JSON-RPC stream.
+import { nodeVersionError } from "./nodeVersion.js";
+const versionError = nodeVersionError();
+if (versionError) {
+    console.error(versionError);
+    process.exit(1);
+}
+//# sourceMappingURL=checkNodeVersion.js.map

package/dist/checkNodeVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkNodeVersion.js","sourceRoot":"","sources":["../src/checkNodeVersion.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,oEAAoE;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,YAAY,GAAG,gBAAgB,EAAE,CAAC;AACxC,IAAI,YAAY,EAAE,CAAC;IACjB,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;IAC5B,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC"}

package/dist/config.d.ts

@@ -1,13 +1,64 @@
+type Environment = NodeJS.ProcessEnv;
 export type McpTransportMode = "stdio" | "http";
+export declare const SQL_AUTH_TYPES: readonly ["sql", "ntlm", "azure-default", "azure-service-principal", "azure-access-token"];
+export type SqlAuthType = (typeof SQL_AUTH_TYPES)[number];
+export type SqlAuthConfig = {
+    type: "sql";
+    user: string;
+    password: string;
+} | {
+    type: "ntlm";
+    user: string;
+    password: string;
+    domain: string;
+} | {
+    type: "azure-default";
+    clientId?: string;
+} | {
+    type: "azure-service-principal";
+    clientId: string;
+    clientSecret: string;
+    tenantId: string;
+} | {
+    type: "azure-access-token";
+    token: string;
+};
+export interface SqlConnectionConfig {
+    serverName: string;
+    serverPort?: number;
+    auth: SqlAuthConfig;
+    encrypt: boolean;
+    trustServerCertificate: boolean;
+    connectionTimeoutSeconds: number;
+    queryTimeoutMs: number;
+}
+export interface EnvironmentConfig extends SqlConnectionConfig {
+    databaseName: string;
+    databases: string[];
+    readOnly: boolean;
+    enableDdl: boolean;
+    maxRows: number;
+    maxWriteRows: number;
+    requireWritePreview: boolean;
+    mcpTransport: McpTransportMode;
+    mcpHttpHost: string;
+    mcpHttpPort: number;
+    mcpBaseUrl?: string;
+    mcpHttpAuthToken?: string;
+    mcpHttpAllowUnauthenticated: boolean;
+    mcpHttpAllowedHosts: string[];
+}
+export declare function configureRuntimeEnvironment(environment: EnvironmentConfig): void;
+export declare function parseDatabaseList(value: string | undefined): string[];
+export declare function parseSqlAuthConfig(env?: Environment): SqlAuthConfig;
+export declare function parseSqlConnectionConfig(env?: Environment): SqlConnectionConfig;
+export declare function parseEnvironmentConfig(env?: Environment): EnvironmentConfig;
 export declare function getMaxRows(): number;
-export declare function getQueryTimeoutMs(): number;
 export declare function getDefaultSearchLimit(): number;
 export declare function clampRowLimit(limit: unknown, fallback?: number): number;
-export declare function getMcpTransport(): McpTransportMode;
-export declare function getMcpHttpPort(): number;
-export declare function getMcpHttpHost(): string;
-export declare function getMcpBaseUrl(): string | undefined;
-export declare function isDdlEnabled(): boolean;
+export declare function getMcpEndpointUrl(environment: Pick<EnvironmentConfig, "mcpBaseUrl" | "mcpHttpHost" | "mcpHttpPort">): string;
+/** Brackets IPv6 literals (`::1` -> `[::1]`) for use in a URL authority. */
+export declare function formatUrlHost(host: string): string;
 export declare function getMaxWriteRows(): number;
-export declare function isWritePreviewRequired(): boolean;
+export {};
 //# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AA4CA,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,MAAM,CAAC;AAEhD,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAK1C;AAED,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,SAAe,GAAG,MAAM,CAa7E;AAED,wBAAgB,eAAe,IAAI,gBAAgB,CAIlD;AAED,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED,wBAAgB,aAAa,IAAI,MAAM,GAAG,SAAS,CAGlD;AAED,wBAAgB,YAAY,IAAI,OAAO,CAEtC;AAED,wBAAgB,eAAe,IAAI,MAAM,CAKxC;AAED,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAQA,KAAK,WAAW,GAAG,MAAM,CAAC,UAAU,CAAC;AAErC,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,MAAM,CAAC;AAEhD,eAAO,MAAM,cAAc,4FAMjB,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1D,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAChE;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5C;IACE,IAAI,EAAE,yBAAyB,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB,GACD;IAAE,IAAI,EAAE,oBAAoB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAElD,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,sBAAsB,EAAE,OAAO,CAAC;IAChC,wBAAwB,EAAE,MAAM,CAAC;IACjC,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,iBAAkB,SAAQ,mBAAmB;IAC5D,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,YAAY,EAAE,gBAAgB,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,2BAA2B,EAAE,OAAO,CAAC;IACrC,mBAAmB,EAAE,MAAM,EAAE,CAAC;CAC/B;AAID,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,iBAAiB,GAC7B,IAAI,CAKN;AAmHD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,CASrE;AAeD,wBAAgB,kBAAkB,CAChC,GAAG,GAAE,WAAyB,GAC7B,aAAa,CAoCf;AAED,wBAAgB,wBAAwB,CACtC,GAAG,GAAE,WAAyB,GAC7B,mBAAmB,CA0BrB;AAED,wBAAgB,sBAAsB,CACpC,GAAG,GAAE,WAAyB,GAC7B,iBAAiB,CAyDnB;AAeD,wBAAgB,UAAU,IAAI,MAAM,CAKnC;AAED,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,SAAe,GAAG,MAAM,CAa7E;AAED,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,IAAI,CACf,iBAAiB,EACjB,YAAY,GAAG,aAAa,GAAG,aAAa,CAC7C,GACA,MAAM,CAKR;AAED,4EAA4E;AAC5E,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,wBAAgB,eAAe,IAAI,MAAM,CASxC"}

package/dist/config.js

@@ -1,37 +1,215 @@
 const DEFAULT_MAX_ROWS = 10000;
 const DEFAULT_QUERY_TIMEOUT_MS = 30000;
 const DEFAULT_SEARCH_LIMIT = 100;
+const DEFAULT_CONNECTION_TIMEOUT_SECONDS = 30;
 const DEFAULT_HTTP_PORT = 3333;
 const DEFAULT_HTTP_HOST = "127.0.0.1";
 const DEFAULT_MAX_WRITE_ROWS = 100;
-function parsePositiveInt(value, fallback, minimum = 1) {
-    if (!value) {
+export const SQL_AUTH_TYPES = [
+    "sql",
+    "ntlm",
+    "azure-default",
+    "azure-service-principal",
+    "azure-access-token",
+];
+let runtimeEnvironment;
+export function configureRuntimeEnvironment(environment) {
+    runtimeEnvironment = {
+        ...environment,
+        databases: [...environment.databases],
+    };
+}
+function parseInteger(name, value, fallback, minimum = 1, maximum) {
+    if (value === undefined || value.trim() === "") {
         return fallback;
     }
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isFinite(parsed) || parsed < minimum) {
-        return fallback;
+    const range = maximum !== undefined
+        ? `between ${minimum} and ${maximum}`
+        : `of at least ${minimum}`;
+    const normalized = value.trim();
+    if (!/^\d+$/.test(normalized)) {
+        throw new Error(`${name} must be a whole number ${range}.`);
+    }
+    const parsed = Number(normalized);
+    if (!Number.isSafeInteger(parsed) ||
+        parsed < minimum ||
+        (maximum !== undefined && parsed > maximum)) {
+        throw new Error(`${name} must be a whole number ${range}.`);
     }
     return parsed;
 }
-function parseBoolean(value, fallback) {
-    if (!value) {
+function parseRequiredString(name, value) {
+    const normalized = value?.trim();
+    if (!normalized) {
+        throw new Error(`${name} is required and must not be blank.`);
+    }
+    return normalized;
+}
+function parseBoolean(name, value, fallback) {
+    if ((value === undefined || value.trim() === "") && fallback !== undefined) {
         return fallback;
     }
-    const normalized = value.trim().toLowerCase();
+    const normalized = value?.trim().toLowerCase();
     if (normalized === "true") {
         return true;
     }
     if (normalized === "false") {
         return false;
     }
-    return fallback;
+    const requirement = fallback === undefined ? "is required and must be" : "must be";
+    throw new Error(`${name} ${requirement} either "true" or "false".`);
 }
-export function getMaxRows() {
-    return parsePositiveInt(process.env.MAX_ROWS, DEFAULT_MAX_ROWS);
+function parseServerPort(value) {
+    if (value === undefined || value.trim() === "") {
+        return undefined;
+    }
+    const normalized = value.trim();
+    if (!/^\d+$/.test(normalized)) {
+        throw new Error("SERVER_PORT must be a valid TCP port between 1 and 65535.");
+    }
+    const port = Number(normalized);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error("SERVER_PORT must be a valid TCP port between 1 and 65535.");
+    }
+    return port;
 }
-export function getQueryTimeoutMs() {
-    return parsePositiveInt(process.env.QUERY_TIMEOUT_MS, DEFAULT_QUERY_TIMEOUT_MS);
+function parseMcpBaseUrl(value) {
+    const normalized = value?.trim();
+    if (!normalized) {
+        return undefined;
+    }
+    let url;
+    try {
+        url = new URL(normalized);
+    }
+    catch {
+        throw new Error("MCP_BASE_URL must be a valid absolute HTTP or HTTPS URL.");
+    }
+    if ((url.protocol !== "http:" && url.protocol !== "https:") ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash) {
+        throw new Error("MCP_BASE_URL must be a valid absolute HTTP or HTTPS URL.");
+    }
+    url.pathname = url.pathname.replace(/\/+$/, "");
+    return url.toString().replace(/\/$/, "");
+}
+export function parseDatabaseList(value) {
+    if (!value?.trim()) {
+        return [];
+    }
+    return value
+        .split(",")
+        .map((database) => database.trim())
+        .filter(Boolean);
+}
+function parseSqlAuthType(value) {
+    if (value === undefined || value.trim() === "") {
+        return "sql";
+    }
+    const normalized = value.trim().toLowerCase();
+    if (SQL_AUTH_TYPES.includes(normalized)) {
+        return normalized;
+    }
+    throw new Error(`SQL_AUTH_TYPE must be one of: ${SQL_AUTH_TYPES.join(", ")}.`);
+}
+export function parseSqlAuthConfig(env = process.env) {
+    const type = parseSqlAuthType(env.SQL_AUTH_TYPE);
+    switch (type) {
+        case "sql":
+            return {
+                type,
+                user: parseRequiredString("DB_USER", env.DB_USER),
+                password: parseRequiredString("DB_PASSWORD", env.DB_PASSWORD),
+            };
+        case "ntlm":
+            return {
+                type,
+                user: parseRequiredString("DB_USER", env.DB_USER),
+                password: parseRequiredString("DB_PASSWORD", env.DB_PASSWORD),
+                domain: parseRequiredString("DB_DOMAIN", env.DB_DOMAIN),
+            };
+        case "azure-default": {
+            const clientId = env.AZURE_CLIENT_ID?.trim();
+            return clientId ? { type, clientId } : { type };
+        }
+        case "azure-service-principal":
+            return {
+                type,
+                clientId: parseRequiredString("AZURE_CLIENT_ID", env.AZURE_CLIENT_ID),
+                clientSecret: parseRequiredString("AZURE_CLIENT_SECRET", env.AZURE_CLIENT_SECRET),
+                tenantId: parseRequiredString("AZURE_TENANT_ID", env.AZURE_TENANT_ID),
+            };
+        case "azure-access-token":
+            return {
+                type,
+                token: parseRequiredString("AZURE_ACCESS_TOKEN", env.AZURE_ACCESS_TOKEN),
+            };
+    }
+}
+export function parseSqlConnectionConfig(env = process.env) {
+    const auth = parseSqlAuthConfig(env);
+    const isEntraAuth = auth.type.startsWith("azure-");
+    return {
+        serverName: env.SERVER_NAME?.trim() || "localhost",
+        serverPort: parseServerPort(env.SERVER_PORT),
+        auth,
+        // Azure SQL requires TLS and presents publicly trusted certificates, so
+        // Entra ID auth types default to encrypting and validating the certificate.
+        encrypt: parseBoolean("ENCRYPT", env.ENCRYPT, isEntraAuth),
+        trustServerCertificate: parseBoolean("TRUST_SERVER_CERTIFICATE", env.TRUST_SERVER_CERTIFICATE, !isEntraAuth),
+        connectionTimeoutSeconds: parseInteger("CONNECTION_TIMEOUT", env.CONNECTION_TIMEOUT, DEFAULT_CONNECTION_TIMEOUT_SECONDS),
+        queryTimeoutMs: parseInteger("QUERY_TIMEOUT_MS", env.QUERY_TIMEOUT_MS, DEFAULT_QUERY_TIMEOUT_MS),
+    };
+}
+export function parseEnvironmentConfig(env = process.env) {
+    const explicitDefault = env.DATABASE_NAME?.trim();
+    const configuredDatabases = parseDatabaseList(env.DATABASES);
+    const databases = configuredDatabases.length > 0
+        ? configuredDatabases
+        : explicitDefault
+            ? [explicitDefault]
+            : [];
+    if (databases.length === 0) {
+        throw new Error("At least one of DATABASE_NAME or DATABASES is required and must contain a database name.");
+    }
+    const databaseName = explicitDefault && databases.includes(explicitDefault)
+        ? explicitDefault
+        : databases[0];
+    return {
+        ...parseSqlConnectionConfig(env),
+        databaseName,
+        databases,
+        readOnly: parseBoolean("READONLY", env.READONLY, false),
+        enableDdl: parseBoolean("ENABLE_DDL", env.ENABLE_DDL, false),
+        maxRows: parseInteger("MAX_ROWS", env.MAX_ROWS, DEFAULT_MAX_ROWS),
+        maxWriteRows: parseInteger("MAX_WRITE_ROWS", env.MAX_WRITE_ROWS, DEFAULT_MAX_WRITE_ROWS),
+        requireWritePreview: parseBoolean("REQUIRE_WRITE_PREVIEW", env.REQUIRE_WRITE_PREVIEW, true),
+        mcpTransport: parseMcpTransport(env.MCP_TRANSPORT),
+        mcpHttpHost: env.MCP_HTTP_HOST?.trim() || DEFAULT_HTTP_HOST,
+        mcpHttpPort: parseInteger("MCP_HTTP_PORT", env.MCP_HTTP_PORT, DEFAULT_HTTP_PORT, 1, 65535),
+        mcpBaseUrl: parseMcpBaseUrl(env.MCP_BASE_URL),
+        mcpHttpAuthToken: env.MCP_HTTP_AUTH_TOKEN?.trim() || undefined,
+        mcpHttpAllowUnauthenticated: parseBoolean("MCP_HTTP_ALLOW_UNAUTHENTICATED", env.MCP_HTTP_ALLOW_UNAUTHENTICATED, false),
+        mcpHttpAllowedHosts: parseDatabaseList(env.MCP_HTTP_ALLOWED_HOSTS).map((host) => host.toLowerCase()),
+    };
+}
+function parseMcpTransport(value) {
+    if (value === undefined || value.trim() === "") {
+        return "stdio";
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "stdio" || normalized === "http") {
+        return normalized;
+    }
+    throw new Error('MCP_TRANSPORT must be either "stdio" or "http".');
+}
+export function getMaxRows() {
+    if (runtimeEnvironment) {
+        return runtimeEnvironment.maxRows;
+    }
+    return parseInteger("MAX_ROWS", process.env.MAX_ROWS, DEFAULT_MAX_ROWS);
 }
 export function getDefaultSearchLimit() {
     return Math.min(getMaxRows(), DEFAULT_SEARCH_LIMIT);
@@ -47,28 +225,19 @@ export function clampRowLimit(limit, fallback = getMaxRows()) {
     }
     return Math.min(Math.floor(parsed), getMaxRows());
 }
-export function getMcpTransport() {
-    return process.env.MCP_TRANSPORT?.trim().toLowerCase() === "http"
-        ? "http"
-        : "stdio";
-}
-export function getMcpHttpPort() {
-    return parsePositiveInt(process.env.MCP_HTTP_PORT, DEFAULT_HTTP_PORT);
+export function getMcpEndpointUrl(environment) {
+    const baseUrl = environment.mcpBaseUrl ??
+        `http://${formatUrlHost(environment.mcpHttpHost)}:${environment.mcpHttpPort}`;
+    return `${baseUrl.replace(/\/+$/, "")}/mcp`;
 }
-export function getMcpHttpHost() {
-    return process.env.MCP_HTTP_HOST?.trim() || DEFAULT_HTTP_HOST;
-}
-export function getMcpBaseUrl() {
-    const value = process.env.MCP_BASE_URL?.trim();
-    return value ? value : undefined;
-}
-export function isDdlEnabled() {
-    return parseBoolean(process.env.ENABLE_DDL, false);
+/** Brackets IPv6 literals (`::1` -> `[::1]`) for use in a URL authority. */
+export function formatUrlHost(host) {
+    return host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
 }
 export function getMaxWriteRows() {
-    return parsePositiveInt(process.env.MAX_WRITE_ROWS, DEFAULT_MAX_WRITE_ROWS);
-}
-export function isWritePreviewRequired() {
-    return parseBoolean(process.env.REQUIRE_WRITE_PREVIEW, true);
+    if (runtimeEnvironment) {
+        return runtimeEnvironment.maxWriteRows;
+    }
+    return parseInteger("MAX_WRITE_ROWS", process.env.MAX_WRITE_ROWS, DEFAULT_MAX_WRITE_ROWS);
 }
 //# sourceMappingURL=config.js.map