@alfe.ai/xero-mcp 0.3.16 → 0.3.17

package/dist/server.cjs

@@ -0,0 +1,856 @@
+#!/usr/bin/env node
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_fs = require("node:fs");
+let node_module = require("node:module");
+let node_path = require("node:path");
+let node_url = require("node:url");
+let _alfe_ai_agent_api_client = require("@alfe.ai/agent-api-client");
+let _alfe_ai_config = require("@alfe.ai/config");
+let _alfe_ai_mcp_bundler = require("@alfe.ai/mcp-bundler");
+let _modelcontextprotocol_sdk_client_index_js = require("@modelcontextprotocol/sdk/client/index.js");
+let _modelcontextprotocol_sdk_client_stdio_js = require("@modelcontextprotocol/sdk/client/stdio.js");
+let _modelcontextprotocol_sdk_server_index_js = require("@modelcontextprotocol/sdk/server/index.js");
+let _modelcontextprotocol_sdk_server_stdio_js = require("@modelcontextprotocol/sdk/server/stdio.js");
+let _modelcontextprotocol_sdk_types_js = require("@modelcontextprotocol/sdk/types.js");
+let node_crypto = require("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 {
+		...environment,
+		XERO_CLIENT_BEARER_TOKEN: token
+	};
+}
+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)
+	};
+}
+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;
+}
+function readRefreshedAccessToken(value) {
+	if (!isRecord(value)) throw new Error("Xero refresh response must be an object");
+	return validateAccessToken(value.accessToken, false);
+}
+function injectTenantSelector(tool) {
+	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: "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;
+}
+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;
+	});
+}
+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 (0, node_crypto.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;
+		}
+	}
+	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");
+	}
+	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;
+	});
+}
+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$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+const CHILD_PACKAGE = "@xeroapi/xero-mcp-server";
+const packageMetadata = require$1("../package.json");
+const childPackagePath = require$1.resolve(`${CHILD_PACKAGE}/package.json`);
+const childMetadata = require$1(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 = (0, node_fs.realpathSync)((0, node_path.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());
+		(0, _alfe_ai_mcp_bundler.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);
+		}
+		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 {
+				return errorResult("Xero token refresh failed. Ask the user to reconnect this organisation from the dashboard.");
+			}
+		}
+		if (!this.catalogToolNames.has(name)) return errorResult(`Unknown Xero tool: ${name}`);
+		let tenant;
+		let forwarded;
+		try {
+			const prepared = prepareForwardedArguments(args);
+			tenant = this.resolveTenant(prepared.xeroTenantId);
+			forwarded = prepared.forwarded;
+		} catch (error) {
+			return publicErrorResult(error);
+		}
+		let result;
+		try {
+			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
+			});
+		}
+		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"));
+			}
+		}
+	}
+	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 _modelcontextprotocol_sdk_client_stdio_js.StdioClientTransport({
+		command: process.execPath,
+		args: [CHILD_BIN_PATH],
+		env: buildChildEnvironment(accessToken),
+		cwd: CHILD_PACKAGE_ROOT,
+		stderr: "ignore"
+	});
+	const client = new _modelcontextprotocol_sdk_client_index_js.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 _modelcontextprotocol_sdk_server_index_js.Server({
+		name: "xero-mcp-proxy",
+		version: SERVER_VERSION
+	}, { capabilities: { tools: {} } });
+	server.setRequestHandler(_modelcontextprotocol_sdk_types_js.ListToolsRequestSchema, () => ({ tools: runtime.listTools() }));
+	server.setRequestHandler(_modelcontextprotocol_sdk_types_js.CallToolRequestSchema, (request) => runtime.handleToolCall(request));
+	return {
+		server,
+		runtime
+	};
+}
+async function startServer(apiClient, options = {}) {
+	let client = apiClient;
+	if (client === void 0) {
+		const config = (0, _alfe_ai_config.resolveConfig)();
+		client = new _alfe_ai_agent_api_client.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 _modelcontextprotocol_sdk_server_stdio_js.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 (0, node_url.pathToFileURL)((0, node_fs.realpathSync)(argvPath)).href === (0, node_url.pathToFileURL)((0, node_fs.realpathSync)((0, node_url.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 || (0, node_path.isAbsolute)(relativeBin)) throw new Error(`${CHILD_PACKAGE} package bin path is invalid`);
+	const packageRoot = (0, node_fs.realpathSync)((0, node_path.dirname)(packagePath));
+	const binPath = (0, node_fs.realpathSync)((0, node_path.resolve)(packageRoot, relativeBin));
+	const childRelative = (0, node_path.relative)(packageRoot, binPath);
+	if (childRelative === "" || childRelative.startsWith("..") || (0, node_path.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], require("url").pathToFileURL(__filename).href)) 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
+exports.CHILD_BIN_PATH = CHILD_BIN_PATH;
+exports.CHILD_PACKAGE_ROOT = CHILD_PACKAGE_ROOT;
+exports.CHILD_VERSION = CHILD_VERSION;
+exports.SERVER_VERSION = SERVER_VERSION;
+exports.XeroRuntime = XeroRuntime;
+exports.createProxyServer = createProxyServer;
+exports.isProcessEntrypoint = isProcessEntrypoint;
+exports.startServer = startServer;