@alfe.ai/xero-mcp 0.3.16 → 0.3.18

package/dist/server.js

@@ -1,367 +1,848 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+import { realpathSync } from "node:fs";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { AgentApiClient } from "@alfe.ai/agent-api-client";
+import { resolveConfig } from "@alfe.ai/config";
+import { assertPatternA } from "@alfe.ai/mcp-bundler";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { resolveConfig } from "@alfe.ai/config";
-import { AgentApiClient } from "@alfe.ai/agent-api-client";
-import { assertPatternA } from "@alfe.ai/mcp-bundler";
-//#region src/server.ts
-/**
-* Xero MCP Proxy Server (Pattern A multi-account)
-*
-* A thin proxy that fans out to one official `@xeroapi/xero-mcp-server`
-* child process per connected Xero tenant. Every credential-touching
-* tool requires the LLM to pass a `xeroTenantId` selector arg; the proxy
-* strips that arg, dispatches to the right child, and returns the result.
-*
-* Pattern A locked in PR 7.3 of channels-and-credential-driven-
-* integrations. See `packages/mcp-bundler/DEVELOPING.md` for the
-* contract; `services/connect/DEVELOPING.md` for the provider table.
-*
-* Architecture:
-*   OpenClaw ←(stdio)→ this proxy ←(stdio fan-out)→ N × @xeroapi/xero-mcp-server
-*
-* Token refresh is per-tenant: Xero access tokens are NOT interchangeable
-* across tenants on the same agent (unlike MYOB), so a 401 from one
-* tenant refreshes only that tenant's token via
-* `apiClient.refreshXeroAccountToken(xeroTenantId)` and respawns only
-* that tenant's child. Xero tokens expire every 30 minutes, so the
-* scheduled refresh path walks every cached tenant on a 25-minute
-* cadence.
-*
-* Uses the low-level Server class (not McpServer) because child tools
-* return JSON Schema objects — McpServer.registerTool requires Zod.
-*/
-const tenants = /* @__PURE__ */ new Map();
-/** Full getXeroAccounts() snapshot — includes rows we couldn't spawn. */
-const allAccountsSnapshot = [];
-/** Cached, selector-injected tool list. */
-let cachedTools = [];
-let refreshTimer = null;
-/**
-* Collapse concurrent refreshes on a per-tenant basis. A burst of 401s
-* across the same tenant share one in-flight refresh call.
-*/
-const inFlightRefreshByTenant = /* @__PURE__ */ new Map();
-const REFRESH_INTERVAL_MS = 1500 * 1e3;
-const REFRESH_RETRY_MS = 60 * 1e3;
-function log(msg) {
-	process.stderr.write(`[xero-mcp-proxy] ${msg}\n`);
-}
-function resolveTenant(xeroTenantId) {
-	if (!xeroTenantId) throw new Error("Missing required xeroTenantId argument. Call xero_list_accounts to see the connected Xero tenants and pass the xeroTenantId you want to target.");
-	const t = tenants.get(xeroTenantId);
-	if (!t) {
-		const known = allAccountsSnapshot.find((s) => s.xeroTenantId === xeroTenantId);
-		if (known && !known.connected) throw new Error(`xeroTenantId ${xeroTenantId} is connected on this agent but the proxy could not initialise a child server for it (reason: ${known.reason ?? "unknown"}). Ask the user to reconnect this Xero tenant from the dashboard.`);
-		throw new Error(`Unknown xeroTenantId: ${xeroTenantId}. Call xero_list_accounts to see the connected Xero tenants on this agent.`);
+import { createHash } from "node:crypto";
+const MAX_FORWARDED_ARGUMENT_BYTES = 2 * 1024 * 1024;
+const MAX_TOOL_RESULT_BYTES = 5 * 1024 * 1024;
+const MAX_SCHEMA_BYTES = 768 * 1024;
+const MAX_CONNECTIONS_RESPONSE_BYTES = 128 * 1024;
+const MAX_JSON_DEPTH = 16;
+const MAX_JSON_NODES = 1e5;
+const MAX_JSON_ARRAY_ITEMS = 5e3;
+const MAX_ARGUMENT_STRING_CHARS = 15e5;
+const MAX_TOKEN_CHARS = 32768;
+const MAX_ERROR_CHARS = 2048;
+const XERO_CONNECTIONS_TIMEOUT_MS = 15e3;
+const XERO_TENANT_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+const TOOL_NAME_PATTERN = /^[A-Za-z0-9_.:-]{1,128}$/u;
+const UNSAFE_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+const RESERVED_TOOLS = new Set(["xero_list_accounts", "xero_refresh_token"]);
+const CHILD_ENV_ALLOWLIST = [
+	"HOME",
+	"TMPDIR",
+	"TMP",
+	"TEMP",
+	"LANG",
+	"LC_ALL",
+	"LC_CTYPE",
+	"TZ",
+	"SSL_CERT_FILE",
+	"SSL_CERT_DIR",
+	"NODE_EXTRA_CA_CERTS",
+	"HTTP_PROXY",
+	"HTTPS_PROXY",
+	"NO_PROXY",
+	"http_proxy",
+	"https_proxy",
+	"no_proxy"
+];
+function buildChildEnvironment(accessToken, source = process.env) {
+	const token = validateAccessToken(accessToken, false);
+	const environment = Object.create(null);
+	for (const name of CHILD_ENV_ALLOWLIST) {
+		const value = source[name];
+		if (value !== void 0 && !containsControlCharacter(value)) environment[name] = value;
 	}
-	return t;
+	return {
+		...environment,
+		XERO_CLIENT_BEARER_TOKEN: token
+	};
 }
-async function spawnChild(accessToken, xeroTenantId) {
-	const transport = new StdioClientTransport({
-		command: "npx",
-		args: ["-y", "@xeroapi/xero-mcp-server"],
-		env: {
-			...process.env,
-			XERO_CLIENT_BEARER_TOKEN: accessToken,
-			XERO_TENANT_ID: xeroTenantId
-		}
-	});
-	const client = new Client({
-		name: "xero-mcp-proxy",
-		version: "2.0.0"
-	});
-	await client.connect(transport);
-	return client;
+function normalizeXeroAccount(value) {
+	if (!isRecord(value)) throw new Error("Xero account must be an object");
+	return {
+		connectionId: validateText("connectionId", value.connectionId, 128),
+		accountIdentifier: validateText("accountIdentifier", value.accountIdentifier, 512),
+		displayName: validateOptionalDisplayText("displayName", value.displayName, 512),
+		connectedAt: validateConnectedAt(value.connectedAt),
+		accessToken: validateAccessToken(value.accessToken, true),
+		xeroTenantId: validateXeroTenantId(value.xeroTenantId)
+	};
 }
-async function killAllChildren() {
-	for (const t of tenants.values()) try {
-		await t.client.close();
-	} catch {}
-	tenants.clear();
+function readXeroAccountsResponse(value) {
+	if (!isRecord(value) || !Array.isArray(value.accounts)) throw new Error("Xero accounts response must contain an accounts array");
+	if (value.accounts.length > 50) throw new Error(`Xero accounts response exceeds ${String(50)} accounts`);
+	return value.accounts;
 }
-/**
-* Refresh a specific tenant's access token and atomically swap its
-* child server. Concurrent callers for the same tenant share one
-* in-flight refresh + respawn.
-*/
-async function refreshTenant(apiClient, xeroTenantId) {
-	const existing = inFlightRefreshByTenant.get(xeroTenantId);
-	if (existing) return existing;
-	const promise = (async () => {
-		try {
-			const { accessToken } = await apiClient.refreshXeroAccountToken(xeroTenantId);
-			const newChild = await spawnChild(accessToken, xeroTenantId);
-			const old = tenants.get(xeroTenantId);
-			tenants.set(xeroTenantId, {
-				xeroTenantId,
-				displayName: old?.displayName ?? null,
-				connectedAt: old?.connectedAt ?? "",
-				accessToken,
-				client: newChild
-			});
-			if (old) try {
-				await old.client.close();
-			} catch {}
-			return accessToken;
-		} finally {
-			inFlightRefreshByTenant.delete(xeroTenantId);
-		}
-	})();
-	inFlightRefreshByTenant.set(xeroTenantId, promise);
-	return promise;
-}
-function scheduleRefresh(apiClient) {
-	if (refreshTimer) clearTimeout(refreshTimer);
-	refreshTimer = setTimeout(() => {
-		(async () => {
-			const tenantIds = Array.from(tenants.keys());
-			if (tenantIds.length === 0) {
-				refreshTimer = setTimeout(() => {
-					scheduleRefresh(apiClient);
-				}, REFRESH_INTERVAL_MS);
-				return;
-			}
-			log(`Refreshing Xero access tokens across ${String(tenantIds.length)} tenant(s)...`);
-			let anyFailed = false;
-			for (const tid of tenantIds) try {
-				await refreshTenant(apiClient, tid);
-			} catch (err) {
-				anyFailed = true;
-				log(`Token refresh failed for tenant ${tid}: ${err instanceof Error ? err.message : String(err)}`);
-			}
-			refreshTimer = setTimeout(() => {
-				scheduleRefresh(apiClient);
-			}, anyFailed ? REFRESH_RETRY_MS : REFRESH_INTERVAL_MS);
-		})();
-	}, REFRESH_INTERVAL_MS);
+function readRefreshedAccessToken(value) {
+	if (!isRecord(value)) throw new Error("Xero refresh response must be an object");
+	return validateAccessToken(value.accessToken, false);
 }
-/**
-* Inject a required `xeroTenantId` string property into a child tool's
-* inputSchema. The proxy strips this arg before forwarding to the child.
-*/
 function injectTenantSelector(tool) {
-	const original = tool.inputSchema ?? {};
-	const originalProperties = original.properties ?? {};
-	const originalRequired = Array.isArray(original.required) ? original.required : [];
-	const injectedProperties = {
-		...originalProperties,
-		xeroTenantId: {
-			type: "string",
-			description: "Xero tenantId — use the value from xero_list_accounts to pick which connected tenant this call should target."
-		}
-	};
-	const injectedRequired = originalRequired.includes("xeroTenantId") ? originalRequired : ["xeroTenantId", ...originalRequired];
-	return {
-		name: tool.name,
-		description: tool.description,
+	if (!isRecord(tool)) throw new Error("Child tool descriptor must be an object");
+	const name = validateToolName(tool.name);
+	if (RESERVED_TOOLS.has(name)) throw new Error(`Child tool collides with reserved proxy tool: ${name}`);
+	const original = cloneJsonRecord("tool input schema", tool.inputSchema, MAX_SCHEMA_BYTES, 5e5);
+	if (Object.hasOwn(original, "type") && original.type !== "object") throw new Error("Child tool input schema must describe an object");
+	const originalProperties = Object.hasOwn(original, "properties") ? cloneJsonRecord("tool schema properties", original.properties, MAX_SCHEMA_BYTES, 5e5) : Object.create(null);
+	const required = new Set(["xeroTenantId", ...validateRequired(original.required)]);
+	const result = {
+		name,
 		inputSchema: {
 			...original,
-			type: original.type ?? "object",
-			properties: injectedProperties,
-			required: injectedRequired
+			type: "object",
+			properties: {
+				...originalProperties,
+				xeroTenantId: {
+					type: "string",
+					pattern: XERO_TENANT_ID_PATTERN.source,
+					maxLength: 36,
+					description: "Xero organisation tenant ID from xero_list_accounts. This required selector chooses the exact connected OAuth organisation."
+				}
+			},
+			required: [...required]
 		}
 	};
+	if (tool.title !== void 0) result.title = validateText("tool title", tool.title, 256);
+	if (tool.description !== void 0) result.description = validateDocumentationText("tool description", tool.description, 2e4);
+	if (tool.outputSchema !== void 0) result.outputSchema = cloneJsonRecord("tool output schema", tool.outputSchema, MAX_SCHEMA_BYTES, 5e5);
+	if (tool.annotations !== void 0) result.annotations = validateAnnotations(tool.annotations);
+	if (tool.execution !== void 0) result.execution = validateExecution(tool.execution);
+	return result;
 }
-async function main() {
-	const config = resolveConfig();
-	const apiClient = new AgentApiClient({
-		apiKey: config.apiKey,
-		apiUrl: config.apiUrl
+function validateToolCatalog(tools) {
+	if (!Array.isArray(tools)) throw new Error("Child tool catalog must be an array");
+	if (tools.length > 150) throw new Error(`Child tool catalog exceeds ${String(150)} tools`);
+	const names = /* @__PURE__ */ new Set();
+	return tools.map((tool) => {
+		const proxied = injectTenantSelector(tool);
+		if (names.has(proxied.name)) throw new Error(`Child tool catalog contains duplicate name: ${proxied.name}`);
+		names.add(proxied.name);
+		return proxied;
 	});
-	const { accounts } = await apiClient.getXeroAccounts();
-	if (accounts.length === 0) log("No Xero tenants connected — proxy will start with xero_list_accounts and xero_refresh_token only");
-	for (const acct of accounts) {
-		if (!acct.accessToken) {
-			log(`Skipping tenant ${acct.xeroTenantId} — no access token`);
-			allAccountsSnapshot.push({
-				xeroTenantId: acct.xeroTenantId,
-				displayName: acct.displayName,
-				connectedAt: acct.connectedAt,
-				connected: false,
-				reason: "missing_access_token"
-			});
-			continue;
-		}
-		if (tenants.has(acct.xeroTenantId)) {
-			log(`Duplicate xeroTenantId ${acct.xeroTenantId} returned by getXeroAccounts() — keeping the first cached child`);
-			continue;
-		}
-		try {
-			const client = await spawnChild(acct.accessToken, acct.xeroTenantId);
-			tenants.set(acct.xeroTenantId, {
-				xeroTenantId: acct.xeroTenantId,
-				displayName: acct.displayName,
-				connectedAt: acct.connectedAt,
-				accessToken: acct.accessToken,
-				client
-			});
-			allAccountsSnapshot.push({
-				xeroTenantId: acct.xeroTenantId,
-				displayName: acct.displayName,
-				connectedAt: acct.connectedAt,
-				connected: true
-			});
-			log(`Spawned child server for tenant ${acct.xeroTenantId} (${acct.displayName ?? "unnamed"})`);
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			log(`Failed to spawn child for tenant ${acct.xeroTenantId}: ${message}`);
-			allAccountsSnapshot.push({
-				xeroTenantId: acct.xeroTenantId,
-				displayName: acct.displayName,
-				connectedAt: acct.connectedAt,
-				connected: false,
-				reason: `spawn_failed: ${message}`
-			});
+}
+function prepareForwardedArguments(value) {
+	const cloned = cloneJsonRecord("tool arguments", value, MAX_FORWARDED_ARGUMENT_BYTES, MAX_ARGUMENT_STRING_CHARS);
+	const xeroTenantId = validateXeroTenantId(cloned.xeroTenantId);
+	const { xeroTenantId: _selector, ...forwarded } = cloned;
+	return {
+		xeroTenantId,
+		forwarded
+	};
+}
+function assertBoundedToolArguments(value) {
+	return cloneJsonRecord("tool arguments", value, MAX_FORWARDED_ARGUMENT_BYTES, MAX_ARGUMENT_STRING_CHARS);
+}
+function assertBoundedToolResult(value) {
+	return cloneJsonRecord("child tool result", value, MAX_TOOL_RESULT_BYTES, MAX_TOOL_RESULT_BYTES);
+}
+function childResultIsError(value) {
+	return value.isError === true;
+}
+function childResultIsUnauthorized(value) {
+	if (!childResultIsError(value)) return false;
+	const text = extractToolErrorText(value).toLowerCase();
+	return text.includes("401") || text.includes("unauthorized") || text.includes("authentication failed");
+}
+function extractToolErrorText(value) {
+	if (!Array.isArray(value.content)) return "";
+	return value.content.slice(0, 100).map((entry) => isRecord(entry) && typeof entry.text === "string" ? entry.text.slice(0, MAX_ERROR_CHARS) : "").join("\n").slice(0, MAX_ERROR_CHARS);
+}
+async function verifyXeroTenantAccess(accessToken, xeroTenantId, fetchFn = fetch, signal = AbortSignal.timeout(XERO_CONNECTIONS_TIMEOUT_MS)) {
+	const token = validateAccessToken(accessToken, false);
+	const selectedTenantId = validateXeroTenantId(xeroTenantId);
+	const response = await fetchFn("https://api.xero.com/connections", {
+		headers: {
+			Authorization: `Bearer ${token}`,
+			Accept: "application/json"
+		},
+		redirect: "error",
+		signal
+	});
+	if (!response.ok) {
+		await response.body?.cancel().catch(() => void 0);
+		throw new Error(`Xero connections request failed with HTTP ${String(response.status)}`);
+	}
+	const text = await readResponseText(response, MAX_CONNECTIONS_RESPONSE_BYTES);
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		throw new Error("Xero connections response was invalid JSON");
+	}
+	if (!Array.isArray(parsed) || parsed.length > 50) throw new Error("Xero connections response was invalid");
+	if (parsed.length !== 1) return "ambiguous";
+	const only = parsed[0];
+	if (!isRecord(only)) throw new Error("Xero connection entry was invalid");
+	return validateXeroTenantId(only.tenantId) === selectedTenantId ? "verified" : "mismatch";
+}
+function snapshotToolCatalog(tools) {
+	return tools.map((tool) => structuredClone(tool));
+}
+function safeErrorMessage(error, secrets = []) {
+	let message = (error instanceof Error ? error.message : String(error)).slice(0, MAX_ERROR_CHARS);
+	for (const secret of secrets) if (secret.length >= 4) message = message.split(secret).join("[REDACTED]");
+	return flattenControls(message).replace(/\b(Bearer|Basic)\s+[^\s,;]+/giu, "$1 [REDACTED]").replace(/\b(api[_-]?key|access[_-]?token|refresh[_-]?token|secret|password)\s*[=:]\s*[^\s,;]+/giu, "$1=[REDACTED]").replace(/https?:\/\/[^\s/@:]+:[^\s/@]+@/giu, "https://[REDACTED]@").replace(/\balfe_[A-Za-z0-9_-]{8,}/gu, "[REDACTED]").slice(0, MAX_ERROR_CHARS);
+}
+function connectionLogId(value) {
+	return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+async function withDeadline(promise, timeoutMs, label) {
+	let timer;
+	try {
+		return await Promise.race([promise, new Promise((_resolve, reject) => {
+			timer = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error(`${label} timed out`));
+			}, timeoutMs);
+			timer.unref();
+		})]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+function validateXeroTenantId(value) {
+	if (typeof value !== "string" || !XERO_TENANT_ID_PATTERN.test(value)) throw new Error("xeroTenantId must be a canonical Xero organisation UUID");
+	return value.toLowerCase();
+}
+function validateAccessToken(value, allowEmpty) {
+	if (allowEmpty && value === "") return "";
+	if (typeof value !== "string" || value.length < 8 || value.length > MAX_TOKEN_CHARS || value !== value.trim() || containsControlCharacter(value)) throw new Error("Xero access token is invalid");
+	return value;
+}
+function validateConnectedAt(value) {
+	const checked = validateText("connectedAt", value, 64);
+	const parsed = new Date(checked);
+	if (Number.isNaN(parsed.valueOf()) || parsed.toISOString() !== checked) throw new Error("connectedAt must be a canonical ISO date-time");
+	return checked;
+}
+function validateToolName(value) {
+	if (typeof value !== "string" || !TOOL_NAME_PATTERN.test(value)) throw new Error("Child tool name is invalid");
+	return value;
+}
+function validateText(label, value, maxChars) {
+	if (typeof value !== "string" || value.length < 1 || value.length > maxChars || containsControlCharacter(value)) throw new Error(`${label} must contain 1 to ${String(maxChars)} non-control characters`);
+	return value;
+}
+function validateOptionalDisplayText(label, value, maxChars) {
+	if (value === null) return null;
+	if (typeof value !== "string" || value.length > maxChars || containsControlCharacter(value)) throw new Error(`${label} must be null or at most ${String(maxChars)} non-control characters`);
+	return value;
+}
+function validateDocumentationText(label, value, maxChars) {
+	if (typeof value !== "string" || value.length < 1 || value.length > maxChars || Array.from(value).some((character) => {
+		const codePoint = character.codePointAt(0) ?? 0;
+		return codePoint < 32 && character !== "\n" && character !== "\r" && character !== "	" || codePoint === 127;
+	})) throw new Error(`${label} must contain 1 to ${String(maxChars)} safe characters`);
+	return value;
+}
+function validateRequired(value) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value) || value.length > 150) throw new Error("tool schema required must be an array");
+	const result = [];
+	for (const entry of value) {
+		if (typeof entry !== "string" || entry.length < 1 || entry.length > 128) throw new Error("tool schema required contains an invalid property name");
+		if (!result.includes(entry)) result.push(entry);
+	}
+	return result;
+}
+function validateAnnotations(value) {
+	if (!isRecord(value)) throw new Error("tool annotations must be an object");
+	const result = {};
+	if (value.title !== void 0) result.title = validateText("annotation title", value.title, 256);
+	for (const key of [
+		"readOnlyHint",
+		"destructiveHint",
+		"idempotentHint",
+		"openWorldHint"
+	]) {
+		const hint = value[key];
+		if (hint !== void 0) {
+			if (typeof hint !== "boolean") throw new Error(`tool annotation ${key} must be boolean`);
+			result[key] = hint;
 		}
 	}
-	const firstTenant = tenants.values().next().value;
-	if (firstTenant) {
-		const { tools } = await firstTenant.client.listTools();
-		cachedTools = tools.map(injectTenantSelector);
-		log(`Child MCP server provides ${String(cachedTools.length)} tools (selector injected)`);
-	} else {
-		cachedTools = [];
-		log("No child server available — only xero_list_accounts and xero_refresh_token will be exposed");
+	return result;
+}
+function validateExecution(value) {
+	if (!isRecord(value)) throw new Error("tool execution metadata must be an object");
+	const taskSupport = value.taskSupport;
+	if (taskSupport !== void 0 && taskSupport !== "optional" && taskSupport !== "required" && taskSupport !== "forbidden") throw new Error("tool execution taskSupport is invalid");
+	return taskSupport === void 0 ? {} : { taskSupport };
+}
+async function readResponseText(response, maxBytes) {
+	const declared = response.headers.get("content-length");
+	if (declared !== null && (!/^\d+$/u.test(declared) || Number(declared) > maxBytes)) {
+		await response.body?.cancel().catch(() => void 0);
+		throw new Error("Xero connections response exceeds the byte limit");
 	}
-	cachedTools.push({
-		name: "xero_list_accounts",
-		description: "List the Xero tenants the agent has connected. Returns one entry per OAuth connection — use the returned xeroTenantId values as the `xeroTenantId` selector arg on every other Xero tool.",
-		inputSchema: {
-			type: "object",
-			properties: {}
+	if (response.body === null) return "";
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let bytes = 0;
+	let text = "";
+	try {
+		for (;;) {
+			const result = await reader.read();
+			if (result.done) break;
+			if (result.value === void 0) throw new Error("Xero response stream returned no bytes");
+			bytes += result.value.byteLength;
+			if (bytes > maxBytes) {
+				await reader.cancel("response too large").catch(() => void 0);
+				throw new Error("Xero connections response exceeds the byte limit");
+			}
+			text += decoder.decode(result.value, { stream: true });
 		}
+		text += decoder.decode();
+		return text;
+	} finally {
+		reader.releaseLock();
+	}
+}
+function cloneJsonRecord(label, value, maxBytes, maxStringChars) {
+	if (!isRecord(value)) throw new Error(`${label} must be an object`);
+	const cloned = cloneRecord(label, value, 0, { nodes: 0 }, maxStringChars);
+	if (Buffer.byteLength(JSON.stringify(cloned), "utf8") > maxBytes) throw new Error(`${label} exceeds the ${String(maxBytes)} byte limit`);
+	return cloned;
+}
+function cloneJson(label, value, depth, budget, maxStringChars) {
+	budget.nodes += 1;
+	if (budget.nodes > MAX_JSON_NODES) throw new Error(`${label} contains too many values`);
+	if (depth > MAX_JSON_DEPTH) throw new Error(`${label} exceeds the JSON depth limit`);
+	if (value === null || typeof value === "boolean") return value;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new Error(`${label} contains a non-finite number`);
+		return value;
+	}
+	if (typeof value === "string") {
+		if (value.length > maxStringChars) throw new Error(`${label} contains an oversized string`);
+		return value;
+	}
+	if (Array.isArray(value)) {
+		if (value.length > MAX_JSON_ARRAY_ITEMS) throw new Error(`${label} contains an oversized array`);
+		return value.map((entry) => cloneJson(label, entry, depth + 1, budget, maxStringChars));
+	}
+	if (!isRecord(value)) throw new Error(`${label} contains a non-JSON value`);
+	return cloneRecord(label, value, depth, budget, maxStringChars);
+}
+function cloneRecord(label, value, depth, budget, maxStringChars) {
+	const result = Object.create(null);
+	for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+		if (key.length < 1 || key.length > 256 || UNSAFE_KEYS.has(key) || descriptor.get !== void 0 || descriptor.set !== void 0) throw new Error(`${label} contains an unsafe property`);
+		result[key] = cloneJson(label, descriptor.value, depth + 1, budget, maxStringChars);
+	}
+	return result;
+}
+function containsControlCharacter(value) {
+	return Array.from(value).some((character) => {
+		const codePoint = character.codePointAt(0) ?? 0;
+		return codePoint < 32 || codePoint === 127;
 	});
-	cachedTools.push({
-		name: "xero_refresh_token",
-		description: "Force-refresh the Xero OAuth2 access token for a specific connected tenant. Use this if Xero API calls are failing with authentication errors. Each Xero tenant has its own access token — pass the tenant you want to refresh.",
-		inputSchema: {
-			type: "object",
-			properties: { xeroTenantId: {
-				type: "string",
-				description: "Xero tenantId — use the value from xero_list_accounts."
-			} },
-			required: ["xeroTenantId"]
+}
+function flattenControls(value) {
+	let output = "";
+	let previousWasControl = false;
+	for (const character of value) {
+		const codePoint = character.codePointAt(0) ?? 0;
+		const isControl = codePoint < 32 || codePoint === 127;
+		if (isControl) {
+			if (!previousWasControl) output += " ";
+		} else output += character;
+		previousWasControl = isControl;
+	}
+	return output;
+}
+function isRecord(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+//#endregion
+//#region src/server.ts
+/**
+* Xero MCP proxy (Pattern A multi-connection boundary).
+*
+* The official child chooses the first organisation returned by Xero and does
+* not consume XERO_TENANT_ID. This proxy therefore starts a child only after a
+* bounded /connections preflight proves that the token exposes exactly one
+* organisation and that it equals the explicit xeroTenantId selector.
+*/
+const require = createRequire(import.meta.url);
+const CHILD_PACKAGE = "@xeroapi/xero-mcp-server";
+const packageMetadata = require("../package.json");
+const childPackagePath = require.resolve(`${CHILD_PACKAGE}/package.json`);
+const childMetadata = require(childPackagePath);
+const SERVER_VERSION = validateSemver("xero-mcp package version", packageMetadata.version);
+const CHILD_VERSION = validateExactChildVersion(packageMetadata.dependencies?.[CHILD_PACKAGE], childMetadata.version);
+const CHILD_BIN_PATH = resolveChildBin(childPackagePath, childMetadata.bin);
+const CHILD_PACKAGE_ROOT = realpathSync(dirname(childPackagePath));
+const CHILD_START_TIMEOUT_MS = 3e4;
+const CHILD_CATALOG_TIMEOUT_MS = 15e3;
+const CHILD_CALL_TIMEOUT_MS = 6e4;
+const CHILD_CLOSE_TIMEOUT_MS = 5e3;
+const TOKEN_REFRESH_TIMEOUT_MS = 3e4;
+const REFRESH_INTERVAL_MS = 1500 * 1e3;
+const REFRESH_RETRY_MS = 60 * 1e3;
+var XeroRuntime = class {
+	tenants = /* @__PURE__ */ new Map();
+	claimedTenantIds = /* @__PURE__ */ new Map();
+	allAccountsSnapshot = [];
+	catalogToolNames = /* @__PURE__ */ new Set();
+	inFlightRefreshByTenant = /* @__PURE__ */ new Map();
+	cachedTools = [];
+	refreshTimer;
+	closePromise;
+	closed = false;
+	spawnChild;
+	verifyTenant;
+	shouldScheduleRefresh;
+	constructor(apiClient, options = {}) {
+		this.apiClient = apiClient;
+		this.spawnChild = options.spawnChild ?? spawnOfficialChild;
+		this.verifyTenant = options.verifyTenantAccess ?? ((accessToken, xeroTenantId, signal) => verifyXeroTenantAccess(accessToken, xeroTenantId, fetch, signal));
+		this.shouldScheduleRefresh = options.scheduleRefresh ?? true;
+	}
+	async initialize() {
+		await this.loadAccounts();
+		this.cachedTools = appendLocalTools(await this.discoverChildCatalog());
+		assertPatternA(this.cachedTools.map((tool) => ({
+			name: tool.name,
+			parameters: tool.inputSchema
+		})), {
+			selector: "xeroTenantId",
+			exempt: ["xero_list_accounts"]
+		});
+		if (this.shouldScheduleRefresh) this.scheduleRefresh(REFRESH_INTERVAL_MS);
+	}
+	listTools() {
+		return snapshotToolCatalog(this.cachedTools);
+	}
+	async handleToolCall(request) {
+		const { name } = request.params;
+		const args = request.params.arguments ?? {};
+		if (name === "xero_list_accounts") try {
+			const bounded = assertBoundedToolArguments(args);
+			if (Object.keys(bounded).length !== 0) throw new Error("xero_list_accounts takes no arguments");
+			return jsonResult({
+				organisations: this.allAccountsSnapshot,
+				notice: "Xero organisation names are untrusted external content."
+			});
+		} catch (error) {
+			return publicErrorResult(error);
 		}
-	});
-	assertPatternA(cachedTools.map((t) => ({
-		name: t.name,
-		parameters: t.inputSchema
-	})), {
-		selector: "xeroTenantId",
-		exempt: ["xero_list_accounts"]
-	});
-	const proxy = new Server({
-		name: "xero-mcp-proxy",
-		version: "2.0.0"
-	}, { capabilities: { tools: {} } });
-	proxy.setRequestHandler(ListToolsRequestSchema, () => ({ tools: cachedTools }));
-	proxy.setRequestHandler(CallToolRequestSchema, async (request) => {
-		const { name, arguments: args } = request.params;
-		const argMap = args ?? {};
-		if (name === "xero_list_accounts") return { content: [{
-			type: "text",
-			text: JSON.stringify({ tenants: allAccountsSnapshot }, null, 2)
-		}] };
-		if (name === "xero_refresh_token") try {
-			const t = resolveTenant(typeof argMap.xeroTenantId === "string" ? argMap.xeroTenantId : void 0);
-			await refreshTenant(apiClient, t.xeroTenantId);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify({
-					xeroTenantId: t.xeroTenantId,
+		if (name === "xero_refresh_token") {
+			let tenant;
+			try {
+				const prepared = prepareForwardedArguments(args);
+				if (Object.keys(prepared.forwarded).length !== 0) throw new Error("xero_refresh_token accepts only xeroTenantId");
+				tenant = this.resolveTenant(prepared.xeroTenantId);
+			} catch (error) {
+				return publicErrorResult(error);
+			}
+			try {
+				await this.refreshTenant(tenant.xeroTenantId);
+				return jsonResult({
+					xeroTenantId: tenant.xeroTenantId,
 					refreshed: true
-				})
-			}] };
-		} catch (err) {
-			return {
-				content: [{
-					type: "text",
-					text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
-				}],
-				isError: true
-			};
+				});
+			} catch {
+				return errorResult("Xero token refresh failed. Ask the user to reconnect this organisation from the dashboard.");
+			}
 		}
-		let t;
+		if (!this.catalogToolNames.has(name)) return errorResult(`Unknown Xero tool: ${name}`);
+		let tenant;
+		let forwarded;
 		try {
-			t = resolveTenant(typeof argMap.xeroTenantId === "string" ? argMap.xeroTenantId : void 0);
-		} catch (err) {
-			return {
-				content: [{
-					type: "text",
-					text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
-				}],
-				isError: true
-			};
+			const prepared = prepareForwardedArguments(args);
+			tenant = this.resolveTenant(prepared.xeroTenantId);
+			forwarded = prepared.forwarded;
+		} catch (error) {
+			return publicErrorResult(error);
 		}
-		const { xeroTenantId: _ignored, ...forwarded } = argMap;
 		let result;
 		try {
-			result = await t.client.callTool({
-				name,
-				arguments: forwarded
+			result = await this.callChild(tenant, name, forwarded);
+		} catch {
+			return errorResult("The selected Xero organisation could not complete the tool call. Retry, then reconnect it if the failure persists.", {
+				xeroTenantId: tenant.xeroTenantId,
+				tool: name
+			});
+		}
+		if (childResultIsUnauthorized(result)) try {
+			await this.refreshTenant(tenant.xeroTenantId);
+			const refreshed = this.resolveTenant(tenant.xeroTenantId);
+			result = await this.callChild(refreshed, name, forwarded);
+		} catch {
+			return errorResult("Xero authentication failed and the credential could not be refreshed. Ask the user to reconnect this organisation from the dashboard.", {
+				xeroTenantId: tenant.xeroTenantId,
+				tool: name
 			});
-		} catch (err) {
-			return {
-				content: [{
-					type: "text",
-					text: JSON.stringify({
-						xeroTenantId: t.xeroTenantId,
-						tool: name,
-						error: err instanceof Error ? err.message : String(err)
-					})
-				}],
-				isError: true
-			};
 		}
-		if (result.isError) {
-			const errorText = result.content.map((c) => c.text ?? "").join("\n");
-			if (errorText.includes("401") || errorText.toLowerCase().includes("unauthorized")) {
-				log(`401 from tenant ${t.xeroTenantId}, refreshing and retrying...`);
-				try {
-					await refreshTenant(apiClient, t.xeroTenantId);
-					const refreshed = tenants.get(t.xeroTenantId);
-					if (!refreshed) throw new Error("Tenant disappeared after refresh");
-					return await refreshed.client.callTool({
-						name,
-						arguments: forwarded
-					});
-				} catch (refreshErr) {
-					return {
-						content: [{
-							type: "text",
-							text: JSON.stringify({
-								xeroTenantId: t.xeroTenantId,
-								error: `Token refresh failed: ${refreshErr instanceof Error ? refreshErr.message : String(refreshErr)}`
-							})
-						}],
-						isError: true
-					};
+		if (childResultIsError(result)) return errorResult(extractToolErrorText(result) || "Xero rejected the tool request", {
+			xeroTenantId: tenant.xeroTenantId,
+			tool: name
+		}, [tenant.accessToken]);
+		return result;
+	}
+	async close() {
+		if (this.closePromise !== void 0) return this.closePromise;
+		this.closed = true;
+		if (this.refreshTimer !== void 0) clearTimeout(this.refreshTimer);
+		this.refreshTimer = void 0;
+		this.closePromise = (async () => {
+			const current = [...this.tenants.values()];
+			this.tenants.clear();
+			await Promise.all(current.map(async ({ client }) => closeChild(client)));
+			await Promise.allSettled([...this.inFlightRefreshByTenant.values()]);
+		})();
+		return this.closePromise;
+	}
+	async loadAccounts() {
+		const rawAccounts = readXeroAccountsResponse(await this.apiClient.getXeroAccounts());
+		if (rawAccounts.length === 0) log("No Xero organisations connected; starting in discovery-only mode");
+		for (const rawAccount of rawAccounts) {
+			let account;
+			try {
+				account = normalizeXeroAccount(rawAccount);
+			} catch (error) {
+				log(`Rejected invalid Xero connection ${typeof rawAccount.connectionId === "string" ? connectionLogId(rawAccount.connectionId) : "invalid"}: ${safeErrorMessage(error)}`);
+				this.allAccountsSnapshot.push({
+					xeroTenantId: null,
+					displayName: null,
+					connectedAt: null,
+					connected: false,
+					reason: "invalid_account"
+				});
+				continue;
+			}
+			if (this.claimedTenantIds.has(account.xeroTenantId)) {
+				log(`Rejected duplicate Xero tenant from connection ${connectionLogId(account.connectionId)}`);
+				this.allAccountsSnapshot.push(summary(account, false, "duplicate_tenant"));
+				continue;
+			}
+			this.claimedTenantIds.set(account.xeroTenantId, account.connectionId);
+			if (account.accessToken.length === 0) {
+				log(`Missing token for Xero connection ${connectionLogId(account.connectionId)}`);
+				this.allAccountsSnapshot.push(summary(account, false, "missing_access_token"));
+				continue;
+			}
+			const controller = new AbortController();
+			let verification;
+			try {
+				verification = await withDeadline(this.verifyTenant(account.accessToken, account.xeroTenantId, controller.signal), CHILD_START_TIMEOUT_MS, "Xero tenant verification");
+			} catch (error) {
+				controller.abort(error);
+				log(`Tenant verification failed for Xero connection ${connectionLogId(account.connectionId)}: ${safeErrorMessage(error, [account.accessToken])}`);
+				this.allAccountsSnapshot.push(summary(account, false, "verification_failed"));
+				continue;
+			}
+			if (verification !== "verified") {
+				this.allAccountsSnapshot.push(summary(account, false, verification === "ambiguous" ? "ambiguous_token" : "tenant_mismatch"));
+				continue;
+			}
+			try {
+				const client = await withDeadline(this.spawnChild(account.accessToken, controller.signal), CHILD_START_TIMEOUT_MS, "Xero child startup");
+				if (this.closed) {
+					await closeChild(client);
+					throw new Error("Xero runtime closed during child startup");
 				}
+				this.tenants.set(account.xeroTenantId, {
+					...account,
+					client
+				});
+				this.allAccountsSnapshot.push(summary(account, true));
+				log(`Spawned child for Xero connection ${connectionLogId(account.connectionId)}`);
+			} catch (error) {
+				controller.abort(error);
+				log(`Child startup failed for Xero connection ${connectionLogId(account.connectionId)}: ${safeErrorMessage(error, [account.accessToken])}`);
+				this.allAccountsSnapshot.push(summary(account, false, "spawn_failed"));
 			}
 		}
-		return result;
-	});
-	scheduleRefresh(apiClient);
-	const transport = new StdioServerTransport();
-	await proxy.connect(transport);
-	log(`Proxy running with ${String(tenants.size)} connected tenant(s) and Pattern A selector enforcement`);
-}
-for (const signal of ["SIGTERM", "SIGINT"]) process.on(signal, () => {
-	if (refreshTimer) clearTimeout(refreshTimer);
-	killAllChildren().then(() => {
-		process.exit(0);
+	}
+	async discoverChildCatalog() {
+		for (const tenant of this.tenants.values()) try {
+			const tools = validateToolCatalog((await withDeadline(tenant.client.listTools(), CHILD_CATALOG_TIMEOUT_MS, "Xero child tool discovery")).tools);
+			for (const tool of tools) this.catalogToolNames.add(tool.name);
+			return tools;
+		} catch (error) {
+			log(`Tool discovery failed for Xero connection ${connectionLogId(tenant.connectionId)}: ${safeErrorMessage(error, [tenant.accessToken])}`);
+		}
+		return [];
+	}
+	resolveTenant(xeroTenantId) {
+		const tenant = this.tenants.get(xeroTenantId);
+		if (tenant !== void 0) return tenant;
+		const known = this.allAccountsSnapshot.find((candidate) => candidate.xeroTenantId === xeroTenantId);
+		if (known !== void 0) throw new Error(`xeroTenantId ${xeroTenantId} is connected but unavailable (${known.reason ?? "unknown"}). Ask the user to reconnect an OAuth credential that exposes exactly this one Xero organisation.`);
+		throw new Error(`Unknown xeroTenantId: ${xeroTenantId}. Call xero_list_accounts to see the connected Xero organisations on this agent.`);
+	}
+	async callChild(tenant, name, forwarded) {
+		return assertBoundedToolResult(await withDeadline(tenant.client.callTool({
+			name,
+			arguments: forwarded
+		}), CHILD_CALL_TIMEOUT_MS, `Xero ${name}`));
+	}
+	refreshTenant(xeroTenantId) {
+		const inFlight = this.inFlightRefreshByTenant.get(xeroTenantId);
+		if (inFlight !== void 0) return inFlight;
+		const current = this.resolveTenant(xeroTenantId);
+		const promise = this.refreshTenantInner(current).finally(() => {
+			if (this.inFlightRefreshByTenant.get(xeroTenantId) === promise) this.inFlightRefreshByTenant.delete(xeroTenantId);
+		});
+		this.inFlightRefreshByTenant.set(xeroTenantId, promise);
+		return promise;
+	}
+	async refreshTenantInner(current) {
+		const accessToken = readRefreshedAccessToken(await withDeadline(this.apiClient.refreshXeroAccountToken(current.accountIdentifier), TOKEN_REFRESH_TIMEOUT_MS, "Xero token refresh"));
+		const controller = new AbortController();
+		let verification;
+		try {
+			verification = await withDeadline(this.verifyTenant(accessToken, current.xeroTenantId, controller.signal), CHILD_START_TIMEOUT_MS, "Xero refreshed tenant verification");
+		} catch (error) {
+			controller.abort(error);
+			throw error;
+		}
+		if (verification !== "verified") {
+			controller.abort();
+			throw new Error("Refreshed Xero token did not map uniquely to the selected organisation");
+		}
+		let nextClient;
+		try {
+			nextClient = await withDeadline(this.spawnChild(accessToken, controller.signal), CHILD_START_TIMEOUT_MS, "Xero refreshed child startup");
+		} catch (error) {
+			controller.abort(error);
+			throw error;
+		}
+		if (this.closed || this.tenants.get(current.xeroTenantId) !== current) {
+			await closeChild(nextClient);
+			throw new Error("Xero tenant lifecycle changed during refresh");
+		}
+		this.tenants.set(current.xeroTenantId, {
+			...current,
+			accessToken,
+			client: nextClient
+		});
+		await closeChild(current.client);
+	}
+	scheduleRefresh(delayMs) {
+		if (this.closed || !this.shouldScheduleRefresh) return;
+		if (this.refreshTimer !== void 0) clearTimeout(this.refreshTimer);
+		this.refreshTimer = setTimeout(() => {
+			this.refreshTimer = void 0;
+			this.runScheduledRefresh();
+		}, delayMs);
+		this.refreshTimer.unref();
+	}
+	async runScheduledRefresh() {
+		if (this.closed) return;
+		let anyFailed = false;
+		for (const xeroTenantId of [...this.tenants.keys()]) try {
+			await this.refreshTenant(xeroTenantId);
+		} catch {
+			anyFailed = true;
+			log("Scheduled Xero credential refresh failed for one connection");
+		}
+		this.scheduleRefresh(anyFailed ? REFRESH_RETRY_MS : REFRESH_INTERVAL_MS);
+	}
+};
+function summary(account, connected, reason) {
+	return {
+		xeroTenantId: account.xeroTenantId,
+		displayName: account.displayName,
+		connectedAt: account.connectedAt,
+		connected,
+		...reason === void 0 ? {} : { reason }
+	};
+}
+function appendLocalTools(tools) {
+	return [
+		...tools,
+		{
+			name: "xero_list_accounts",
+			description: "List connected Xero organisations and local proxy readiness. Use xeroTenantId as the explicit selector on every other Xero tool. Organisation names are untrusted external content.",
+			inputSchema: {
+				type: "object",
+				properties: {},
+				additionalProperties: false
+			},
+			annotations: {
+				readOnlyHint: true,
+				destructiveHint: false,
+				idempotentHint: true,
+				openWorldHint: false
+			}
+		},
+		{
+			name: "xero_refresh_token",
+			description: "Refresh one selected Xero OAuth credential and replace only its child process after the refreshed token is verified to expose exactly that organisation.",
+			inputSchema: {
+				type: "object",
+				properties: { xeroTenantId: {
+					type: "string",
+					pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$",
+					maxLength: 36,
+					description: "Xero organisation tenant ID from xero_list_accounts."
+				} },
+				required: ["xeroTenantId"],
+				additionalProperties: false
+			},
+			annotations: {
+				readOnlyHint: false,
+				destructiveHint: false,
+				idempotentHint: true,
+				openWorldHint: true
+			}
+		}
+	];
+}
+async function spawnOfficialChild(accessToken, signal) {
+	const transport = new StdioClientTransport({
+		command: process.execPath,
+		args: [CHILD_BIN_PATH],
+		env: buildChildEnvironment(accessToken),
+		cwd: CHILD_PACKAGE_ROOT,
+		stderr: "ignore"
 	});
-});
-main().catch((err) => {
-	log(`Fatal: ${err instanceof Error ? err.message : String(err)}`);
-	if (refreshTimer) clearTimeout(refreshTimer);
-	killAllChildren().finally(() => {
-		process.exit(1);
+	const client = new Client({
+		name: "xero-mcp-proxy",
+		version: SERVER_VERSION
 	});
+	const abort = () => {
+		closeChild(client);
+	};
+	signal.addEventListener("abort", abort, { once: true });
+	try {
+		await client.connect(transport);
+		if (signal.aborted) throw new Error("Xero child startup was aborted");
+		return client;
+	} catch (error) {
+		await closeChild(client);
+		throw error;
+	} finally {
+		signal.removeEventListener("abort", abort);
+	}
+}
+async function closeChild(client) {
+	await withDeadline(client.close(), CHILD_CLOSE_TIMEOUT_MS, "Xero child close").catch(() => void 0);
+}
+async function createProxyServer(apiClient, options = {}) {
+	const runtime = new XeroRuntime(apiClient, options);
+	try {
+		await runtime.initialize();
+	} catch (error) {
+		await runtime.close();
+		throw error;
+	}
+	const server = new Server({
+		name: "xero-mcp-proxy",
+		version: SERVER_VERSION
+	}, { capabilities: { tools: {} } });
+	server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: runtime.listTools() }));
+	server.setRequestHandler(CallToolRequestSchema, (request) => runtime.handleToolCall(request));
+	return {
+		server,
+		runtime
+	};
+}
+async function startServer(apiClient, options = {}) {
+	let client = apiClient;
+	if (client === void 0) {
+		const config = resolveConfig();
+		client = new AgentApiClient({
+			apiKey: config.apiKey,
+			apiUrl: config.apiUrl
+		});
+	}
+	const { server, runtime } = await createProxyServer(client, options);
+	let closePromise;
+	const close = () => {
+		closePromise ??= Promise.all([runtime.close(), withDeadline(server.close(), CHILD_CLOSE_TIMEOUT_MS, "Xero proxy close").catch(() => void 0)]).then(() => void 0);
+		return closePromise;
+	};
+	try {
+		await server.connect(new StdioServerTransport());
+		log(`Proxy running with ${String(runtime.listTools().length - 2)} child tool(s)`);
+		return {
+			server,
+			runtime,
+			close
+		};
+	} catch (error) {
+		await close();
+		throw error;
+	}
+}
+function isProcessEntrypoint(argvPath, metaUrl) {
+	try {
+		if (!argvPath) return false;
+		return pathToFileURL(realpathSync(argvPath)).href === pathToFileURL(realpathSync(fileURLToPath(metaUrl))).href;
+	} catch {
+		return false;
+	}
+}
+function resolveChildBin(packagePath, bin) {
+	let relativeBin;
+	if (typeof bin === "string") relativeBin = bin;
+	else if (bin !== null && typeof bin === "object" && !Array.isArray(bin)) relativeBin = bin["xero-mcp-server"];
+	if (typeof relativeBin !== "string" || relativeBin.length === 0 || isAbsolute(relativeBin)) throw new Error(`${CHILD_PACKAGE} package bin path is invalid`);
+	const packageRoot = realpathSync(dirname(packagePath));
+	const binPath = realpathSync(resolve(packageRoot, relativeBin));
+	const childRelative = relative(packageRoot, binPath);
+	if (childRelative === "" || childRelative.startsWith("..") || isAbsolute(childRelative)) throw new Error(`${CHILD_PACKAGE} package bin resolves outside its package`);
+	return binPath;
+}
+function validateExactChildVersion(declared, installed) {
+	const declaredVersion = validateSemver(`${CHILD_PACKAGE} dependency`, declared);
+	const installedVersion = validateSemver(`${CHILD_PACKAGE} installed version`, installed);
+	if (declaredVersion !== installedVersion) throw new Error(`${CHILD_PACKAGE} installed version ${installedVersion} does not match exact dependency ${declaredVersion}`);
+	return declaredVersion;
+}
+function validateSemver(label, value) {
+	if (typeof value !== "string" || !/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/u.test(value)) throw new Error(`${label} is invalid`);
+	return value;
+}
+function jsonResult(data) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(data)
+	}] };
+}
+function publicErrorResult(error) {
+	return errorResult(safeErrorMessage(error));
+}
+function errorResult(error, context = {}, secrets = []) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify({
+				...context,
+				error: safeErrorMessage(error, secrets)
+			})
+		}],
+		isError: true
+	};
+}
+function log(message) {
+	process.stderr.write(`[xero-mcp-proxy] ${message}\n`);
+}
+if (isProcessEntrypoint(process.argv[1], import.meta.url)) startServer().then((running) => {
+	let shutdownPromise;
+	const shutdown = () => {
+		if (shutdownPromise !== void 0) return;
+		shutdownPromise = running.close().catch((error) => {
+			log(`Failed to close cleanly: ${safeErrorMessage(error)}`);
+		}).then(() => {
+			process.exitCode = 0;
+		});
+	};
+	process.once("SIGTERM", shutdown);
+	process.once("SIGINT", shutdown);
+}).catch((error) => {
+	log(`Fatal: ${safeErrorMessage(error)}`);
+	process.exitCode = 1;
 });
 //#endregion
-export {};
+export { CHILD_BIN_PATH, CHILD_PACKAGE_ROOT, CHILD_VERSION, SERVER_VERSION, XeroRuntime, createProxyServer, isProcessEntrypoint, startServer };