@alfe.ai/atlassian-mcp 0.3.17 → 0.3.19

package/README.md

@@ -10,6 +10,13 @@ Part of [**Alfe**](https://alfe.ai) — the operating system for AI agents: buil
 npm install @alfe.ai/atlassian-mcp
 ```
 
+The proxy supports multiple Atlassian OAuth Connections and Cloud sites.
+Every Jira/Confluence tool requires the `cloudId` returned by
+`atlassian_list_accounts`; access tokens stay bound to that selector's
+first authoritative Connection. The pinned Python child receives no OAuth
+client secret or unrelated daemon environment, and permanent deletion
+tools require an exact target confirmation.
+
 ## Links
 
 - 🌐 Website: <https://alfe.ai>

package/dist/server.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
@@ -7,6 +8,380 @@ 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";
+import { createHash } from "node:crypto";
+//#region src/boundary.ts
+const MAX_FORWARDED_ARGUMENT_BYTES = 1024 * 1024;
+const MAX_TOOL_RESULT_BYTES = 5 * 1024 * 1024;
+const MAX_SCHEMA_BYTES = 512 * 1024;
+const MAX_CHECK_RESPONSE_BYTES = 64 * 1024;
+const MAX_JSON_DEPTH = 10;
+const MAX_JSON_NODES = 2e4;
+const MAX_JSON_ARRAY_ITEMS = 1e3;
+const MAX_ARGUMENT_STRING_CHARS = 25e4;
+const MAX_TOKEN_CHARS = 16384;
+const MAX_ERROR_CHARS = 2048;
+const ATLASSIAN_CHECK_TIMEOUT_MS = 15e3;
+const CLOUD_ID_PATTERN = /^[A-Za-z0-9-]{1,128}$/u;
+const TOOL_NAME_PATTERN = /^[A-Za-z0-9_.:-]{1,128}$/u;
+const UNSAFE_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+const RESERVED_TOOLS = new Set([
+	"atlassian_list_accounts",
+	"atlassian_check_connection",
+	"atlassian_refresh_token"
+]);
+const CHILD_ENV_ALLOWLIST = [
+	"PATH",
+	"HOME",
+	"TMPDIR",
+	"TMP",
+	"TEMP",
+	"LANG",
+	"LC_ALL",
+	"LC_CTYPE",
+	"TZ",
+	"SSL_CERT_FILE",
+	"SSL_CERT_DIR",
+	"REQUESTS_CA_BUNDLE",
+	"CURL_CA_BUNDLE",
+	"HTTP_PROXY",
+	"HTTPS_PROXY",
+	"NO_PROXY",
+	"http_proxy",
+	"https_proxy",
+	"no_proxy",
+	"UV_CACHE_DIR",
+	"XDG_CACHE_HOME"
+];
+const CONFIRMATION_RULES = {
+	jira_delete_issue: {
+		targetField: "issue_key",
+		confirmationField: "confirmIssueKey",
+		description: "Repeat the exact issue_key to confirm permanent Jira issue deletion."
+	},
+	jira_remove_issue_link: {
+		targetField: "link_id",
+		confirmationField: "confirmLinkId",
+		description: "Repeat the exact link_id to confirm removal of this Jira issue link."
+	},
+	confluence_delete_page: {
+		targetField: "page_id",
+		confirmationField: "confirmPageId",
+		description: "Repeat the exact page_id to confirm permanent Confluence page deletion."
+	},
+	confluence_delete_attachment: {
+		targetField: "attachment_id",
+		confirmationField: "confirmAttachmentId",
+		description: "Repeat the exact attachment_id to confirm permanent deletion of the attachment and all versions."
+	}
+};
+function buildChildEnvironment(accessToken, cloudId, source = process.env) {
+	const token = validateAccessToken(accessToken);
+	const validatedCloudId = validateCloudId(cloudId);
+	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,
+		PYTHONUNBUFFERED: "1",
+		ATLASSIAN_OAUTH_ENABLE: "true",
+		ATLASSIAN_OAUTH_ACCESS_TOKEN: token,
+		ATLASSIAN_OAUTH_CLOUD_ID: validatedCloudId
+	};
+}
+function injectCloudIdSelector(tool) {
+	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, 1e5);
+	const propertiesValue = Reflect.get(original, "properties");
+	const originalProperties = propertiesValue === void 0 ? Object.create(null) : cloneJsonRecord("tool schema properties", propertiesValue, MAX_SCHEMA_BYTES, 1e5);
+	const originalRequired = validateRequired(Reflect.get(original, "required"));
+	const confirmation = CONFIRMATION_RULES[name];
+	const properties = {
+		...originalProperties,
+		cloudId: {
+			type: "string",
+			pattern: CLOUD_ID_PATTERN.source,
+			maxLength: 128,
+			description: "Atlassian Cloud site ID from atlassian_list_accounts. This required selector chooses the exact Jira/Confluence site."
+		}
+	};
+	const required = new Set(["cloudId", ...originalRequired]);
+	if (confirmation !== void 0) {
+		properties[confirmation.confirmationField] = {
+			type: "string",
+			maxLength: 256,
+			description: confirmation.description
+		};
+		required.add(confirmation.confirmationField);
+	}
+	const result = {
+		name,
+		inputSchema: {
+			...original,
+			type: "object",
+			properties,
+			required: [...required]
+		}
+	};
+	if (tool.title !== void 0) result.title = validateText("tool title", tool.title, 256);
+	if (tool.description !== void 0) result.description = validateText("tool description", tool.description, 2e4);
+	if (tool.outputSchema !== void 0) result.outputSchema = cloneJsonRecord("tool output schema", tool.outputSchema, MAX_SCHEMA_BYTES, 1e5);
+	if (tool.annotations !== void 0) result.annotations = validateAnnotations(tool.annotations);
+	if (tool.execution !== void 0) {
+		if (!isRecord(tool.execution)) throw new Error("tool execution metadata must be an object");
+		const taskSupport = Reflect.get(tool.execution, "taskSupport");
+		if (taskSupport !== void 0 && taskSupport !== "optional" && taskSupport !== "required" && taskSupport !== "forbidden") throw new Error("tool execution taskSupport is invalid");
+		if (taskSupport !== void 0) result.execution = { taskSupport };
+	}
+	return result;
+}
+function validateToolCatalog(tools) {
+	if (tools.length > 250) throw new Error(`Child tool catalog exceeds ${String(250)} tools`);
+	const names = /* @__PURE__ */ new Set();
+	return tools.map((tool) => {
+		const proxied = injectCloudIdSelector(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(toolName, args) {
+	const cloned = cloneJsonRecord("tool arguments", args, MAX_FORWARDED_ARGUMENT_BYTES, MAX_ARGUMENT_STRING_CHARS);
+	validateCloudId(readRequiredString(cloned, "cloudId"));
+	const confirmation = CONFIRMATION_RULES[toolName];
+	if (confirmation !== void 0) {
+		const target = readRequiredString(cloned, confirmation.targetField);
+		if (readRequiredString(cloned, confirmation.confirmationField) !== target) throw new Error(`${confirmation.confirmationField} must exactly match ${confirmation.targetField}`);
+	}
+	const proxyOnlyFields = new Set(["cloudId"]);
+	if (confirmation !== void 0) proxyOnlyFields.add(confirmation.confirmationField);
+	return Object.fromEntries(Object.entries(cloned).filter(([key]) => !proxyOnlyFields.has(key)));
+}
+function assertBoundedToolArguments(value) {
+	return cloneJsonRecord("tool arguments", value, MAX_FORWARDED_ARGUMENT_BYTES, MAX_ARGUMENT_STRING_CHARS);
+}
+function assertBoundedToolResult(value) {
+	assertJsonBudget("child tool result", value, MAX_TOOL_RESULT_BYTES, MAX_TOOL_RESULT_BYTES);
+	return value;
+}
+function extractToolErrorText(value) {
+	if (!isRecord(value) || !Array.isArray(value.content)) return "";
+	return value.content.slice(0, 100).map((content) => isRecord(content) && typeof content.text === "string" ? content.text.slice(0, MAX_ERROR_CHARS) : "").join("\n").slice(0, MAX_ERROR_CHARS);
+}
+async function checkAtlassianConnection(accessToken, fetchFn = fetch) {
+	const response = await fetchFn("https://api.atlassian.com/me", {
+		headers: {
+			Authorization: `Bearer ${validateAccessToken(accessToken)}`,
+			Accept: "application/json"
+		},
+		redirect: "error",
+		signal: AbortSignal.timeout(ATLASSIAN_CHECK_TIMEOUT_MS)
+	});
+	if (!response.ok) {
+		await response.body?.cancel().catch(() => void 0);
+		return {
+			ok: false,
+			status: response.status
+		};
+	}
+	const text = await readResponseText(response, MAX_CHECK_RESPONSE_BYTES);
+	const parsed = JSON.parse(text);
+	assertJsonBudget("Atlassian /me response", parsed, MAX_CHECK_RESPONSE_BYTES, MAX_CHECK_RESPONSE_BYTES);
+	return {
+		ok: true,
+		status: response.status,
+		user: parsed
+	};
+}
+function validateCloudId(value) {
+	if (!CLOUD_ID_PATTERN.test(value)) throw new Error("cloudId must be 1 to 128 letters, digits, or hyphens");
+	return value;
+}
+function validateAccountIdentifier(value) {
+	return validateText("accountIdentifier", value, 320);
+}
+function validateDisplayName(value) {
+	return validateText("display name", value, 256);
+}
+function validateSiteName(value) {
+	return validateText("site name", value, 256);
+}
+function validateConnectedAt(value) {
+	const validated = validateText("connectedAt", value, 64);
+	const parsed = new Date(validated);
+	if (Number.isNaN(parsed.valueOf()) || parsed.toISOString() !== validated) throw new Error("connectedAt must be a canonical ISO date-time");
+	return validated;
+}
+function validateSiteUrl(value) {
+	let parsed;
+	try {
+		parsed = new URL(value);
+	} catch {
+		throw new Error("site URL must be a canonical Atlassian Cloud origin");
+	}
+	if (parsed.protocol !== "https:" || !parsed.hostname.endsWith(".atlassian.net") || parsed.hostname === ".atlassian.net" || parsed.username !== "" || parsed.password !== "" || parsed.port !== "" || parsed.pathname !== "/" || parsed.search !== "" || parsed.hash !== "") throw new Error("site URL must be a canonical https://<site>.atlassian.net origin");
+	return parsed.origin;
+}
+function safeErrorMessage(error, secrets = []) {
+	let message = error instanceof Error ? error.message : String(error);
+	for (const secret of secrets) if (secret.length > 0) message = message.split(secret).join("[REDACTED]");
+	return message.replace(/Bearer\s+[^\s,;]+/giu, "Bearer [REDACTED]").replace(/alfe_(?:dev|test|demo|live)_[a-f0-9]{16,}/giu, "[REDACTED_ALFE_KEY]").slice(0, MAX_ERROR_CHARS);
+}
+function connectionLogId(accountIdentifier) {
+	return createHash("sha256").update(accountIdentifier).digest("hex").slice(0, 12);
+}
+/**
+* Claim a cloud selector for exactly one Connection for this process.
+* A failed child spawn does not release the claim: refresh recovery must
+* remain bound to the first authoritative owner instead of letting a later
+* duplicate Connection take over the selector.
+*/
+function claimCloudId(claims, cloudId, accountIdentifier) {
+	const id = validateCloudId(cloudId);
+	const owner = validateAccountIdentifier(accountIdentifier);
+	if (claims.has(id)) return false;
+	claims.set(id, owner);
+	return true;
+}
+function validateAccessToken(value) {
+	if (value.length < 1 || value.length > MAX_TOKEN_CHARS || containsControlCharacter(value)) throw new Error("Atlassian access token is invalid");
+	return value;
+}
+function validateToolName(value) {
+	if (!TOOL_NAME_PATTERN.test(value)) throw new Error("Child tool name is invalid");
+	return value;
+}
+function validateText(label, value, maxChars) {
+	if (value.length < 1 || value.length > maxChars || containsControlCharacter(value)) throw new Error(`${label} must contain 1 to ${String(maxChars)} non-control characters`);
+	return value;
+}
+function validateRequired(value) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value) || value.length > 250) 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 = {};
+	const title = value.title;
+	if (title !== void 0) {
+		if (typeof title !== "string") throw new Error("tool annotation title must be a string");
+		result.title = validateText("tool annotation title", 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 readRequiredString(value, key) {
+	const candidate = value[key];
+	if (typeof candidate !== "string" || candidate.length < 1 || candidate.length > 256) throw new Error(`${key} must be a non-empty string of at most 256 characters`);
+	return candidate;
+}
+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("Atlassian /me 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 readResult = await reader.read();
+			if (readResult.done) break;
+			const chunk = readResult.value;
+			if (chunk === void 0) throw new Error("Atlassian /me response stream returned no bytes");
+			bytes += chunk.byteLength;
+			if (bytes > maxBytes) {
+				await reader.cancel("response too large").catch(() => void 0);
+				throw new Error("Atlassian /me response exceeds the byte limit");
+			}
+			text += decoder.decode(chunk, { 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 assertJsonBudget(label, value, maxBytes, maxStringChars) {
+	cloneJson(label, value, 0, { nodes: 0 }, maxStringChars);
+	let encoded;
+	try {
+		encoded = JSON.stringify(value);
+	} catch {
+		throw new Error(`${label} must be JSON serializable`);
+	}
+	if (Buffer.byteLength(encoded, "utf8") > maxBytes) throw new Error(`${label} exceeds the ${String(maxBytes)} byte limit`);
+}
+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, nested] of Object.entries(value)) {
+		if (key.length < 1 || key.length > 256 || UNSAFE_KEYS.has(key)) throw new Error(`${label} contains an unsafe property name`);
+		result[key] = cloneJson(label, nested, depth + 1, budget, maxStringChars);
+	}
+	return result;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function containsControlCharacter(value) {
+	return Array.from(value).some((character) => {
+		const codePoint = character.codePointAt(0) ?? 0;
+		return codePoint < 32 || codePoint === 127;
+	});
+}
+//#endregion
 //#region src/server.ts
 /**
 * Atlassian MCP Proxy Server (Pattern A multi-site)
@@ -44,17 +419,29 @@ import { assertPatternA } from "@alfe.ai/mcp-bundler";
 * Uses the low-level Server class (not McpServer) because child tools
 * return JSON Schema objects — McpServer.registerTool requires Zod.
 */
+const packageMetadata = createRequire(import.meta.url)("../package.json");
 /** Per-site child cache. Keyed by cloudId (the Pattern A selector). */
 const sites = /* @__PURE__ */ new Map();
 /** Per-Connection bookkeeping for refresh fan-out. Keyed by accountIdentifier (email). */
 const connections = /* @__PURE__ */ new Map();
+/** Authoritative first-owner claim for every Pattern A selector. */
+const cloudOwners = /* @__PURE__ */ new Map();
 /**
 * Full snapshot of every (Connection × site) row, including ones we
 * couldn't spawn a child for. `atlassian_list_accounts` returns this so
 * the LLM can surface partial-failure rows.
 */
 const allSitesSnapshot = [];
+const siteSummaryIndexes = /* @__PURE__ */ new Map();
 let cachedTools = [];
+let childCatalogLoaded = false;
+let catalogLoadPromise = null;
+let proxyServer = null;
+const META_TOOL_NAMES = new Set([
+	"atlassian_list_accounts",
+	"atlassian_check_connection",
+	"atlassian_refresh_token"
+]);
 let refreshTimer = null;
 /**
 * Collapse concurrent refreshes on a per-Connection basis. A burst of
@@ -63,6 +450,7 @@ let refreshTimer = null;
 const inFlightRefreshByConnection = /* @__PURE__ */ new Map();
 const REFRESH_INTERVAL_MS = 2700 * 1e3;
 const REFRESH_RETRY_MS = 60 * 1e3;
+const CHILD_START_TIMEOUT_MS = 3e4;
 /**
 * Pin the child mcp-atlassian version. The package is distributed via
 * PyPI / uvx, so `uvx mcp-atlassian@<version>` resolves a pinned wheel.
@@ -70,50 +458,65 @@ const REFRESH_RETRY_MS = 60 * 1e3;
 * this string is the single source of truth.
 */
 const CHILD_MCP_ATLASSIAN_VERSION = "0.21.1";
-const ATLASSIAN_SCOPE = "read:jira-user read:jira-work write:jira-work read:confluence-content.all write:confluence-content offline_access";
 function log(msg) {
 	process.stderr.write(`[atlassian-mcp-proxy] ${msg}\n`);
 }
 /**
-* Upsert a row in `allSitesSnapshot`, keyed by (ownerAccountIdentifier,
-* cloudId). Used so refresh respawn outcomes overwrite the startup row
+* Upsert a row in `allSitesSnapshot`, keyed internally by Connection and
+* cloudId. The private account identifier is never serialized to the LLM.
+* Used so refresh respawn outcomes overwrite the startup row
 * rather than appending a stale duplicate.
 */
-function upsertSiteSummary(summary) {
-	const idx = allSitesSnapshot.findIndex((s) => s.cloudId === summary.cloudId && s.ownerAccountIdentifier === summary.ownerAccountIdentifier);
-	if (idx >= 0) allSitesSnapshot[idx] = summary;
-	else allSitesSnapshot.push(summary);
+function upsertSiteSummary(accountIdentifier, summary) {
+	const key = `${accountIdentifier}\u0000${summary.cloudId ?? ""}`;
+	const idx = siteSummaryIndexes.get(key);
+	if (idx !== void 0) allSitesSnapshot[idx] = summary;
+	else {
+		siteSummaryIndexes.set(key, allSitesSnapshot.length);
+		allSitesSnapshot.push(summary);
+	}
 }
 function resolveSite(cloudId) {
 	if (!cloudId) throw new Error("Missing required cloudId argument. Call atlassian_list_accounts to see the connected Atlassian sites and pass the cloudId you want to target.");
-	const site = sites.get(cloudId);
+	const validatedCloudId = validateCloudId(cloudId);
+	const site = sites.get(validatedCloudId);
 	if (!site) {
-		const known = allSitesSnapshot.find((s) => s.cloudId === cloudId);
-		if (known && !known.connected) throw new Error(`cloudId ${cloudId} 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 Atlassian account from the dashboard.`);
-		throw new Error(`Unknown cloudId: ${cloudId}. Call atlassian_list_accounts to see the connected Atlassian sites on this agent.`);
+		const known = allSitesSnapshot.find((s) => s.cloudId === validatedCloudId);
+		if (known && !known.connected) throw new Error(`cloudId ${validatedCloudId} is connected on this agent but the proxy could not initialise a child server for it (reason: ${known.reason ?? "unknown"}). Try atlassian_refresh_token for this cloudId; if that fails ask the user to reconnect this Atlassian account.`);
+		throw new Error(`Unknown cloudId: ${validatedCloudId}. Call atlassian_list_accounts to see the connected Atlassian sites on this agent.`);
 	}
 	return site;
 }
-async function spawnChild(accessToken, cloudId, clientId, clientSecret) {
+function resolveConnectionForCloudId(cloudId) {
+	if (!cloudId) throw new Error("Missing required cloudId argument. Call atlassian_list_accounts first.");
+	const validatedCloudId = validateCloudId(cloudId);
+	const owner = cloudOwners.get(validatedCloudId);
+	if (!owner) throw new Error(`Unknown cloudId: ${validatedCloudId}. Call atlassian_list_accounts first.`);
+	const connection = connections.get(owner);
+	if (!connection) throw new Error("Owning Connection is unavailable in proxy bookkeeping");
+	return connection;
+}
+async function spawnChild(accessToken, cloudId) {
 	const transport = new StdioClientTransport({
 		command: "uvx",
 		args: [`mcp-atlassian@${CHILD_MCP_ATLASSIAN_VERSION}`],
-		env: {
-			...process.env,
-			ATLASSIAN_OAUTH_ENABLE: "true",
-			ATLASSIAN_OAUTH_ACCESS_TOKEN: accessToken,
-			ATLASSIAN_OAUTH_CLOUD_ID: cloudId,
-			ATLASSIAN_OAUTH_CLIENT_ID: clientId,
-			ATLASSIAN_OAUTH_CLIENT_SECRET: clientSecret,
-			ATLASSIAN_OAUTH_SCOPE: ATLASSIAN_SCOPE
-		}
+		env: buildChildEnvironment(accessToken, cloudId)
 	});
 	const client = new Client({
 		name: "atlassian-mcp-proxy",
-		version: "0.1.0"
+		version: packageMetadata.version
 	});
-	await client.connect(transport);
-	return client;
+	try {
+		await client.connect(transport, {
+			timeout: CHILD_START_TIMEOUT_MS,
+			signal: AbortSignal.timeout(CHILD_START_TIMEOUT_MS)
+		});
+		return client;
+	} catch (error) {
+		await transport.close().catch(() => void 0);
+		await client.close().catch(() => void 0);
+		throw error;
+	}
 }
 async function killAllChildren() {
 	for (const site of sites.values()) try {
@@ -121,12 +524,31 @@ async function killAllChildren() {
 	} catch {}
 	sites.clear();
 }
+async function ensureChildToolCatalog(client, notify) {
+	if (childCatalogLoaded) return;
+	if (catalogLoadPromise !== null) return catalogLoadPromise;
+	catalogLoadPromise = (async () => {
+		const { tools } = await client.listTools(void 0, {
+			timeout: 3e4,
+			signal: AbortSignal.timeout(3e4)
+		});
+		const childTools = validateToolCatalog(tools);
+		const metaTools = cachedTools.filter((tool) => META_TOOL_NAMES.has(tool.name));
+		cachedTools = [...childTools, ...metaTools];
+		childCatalogLoaded = true;
+		log(`Child MCP server provides ${String(childTools.length)} validated tools`);
+		if (notify && proxyServer !== null) await proxyServer.sendToolListChanged();
+	})().finally(() => {
+		catalogLoadPromise = null;
+	});
+	return catalogLoadPromise;
+}
 /**
 * Refresh a specific Connection's access token and atomically swap every
 * child server bound to a cloudId owned by that Connection. Concurrent
 * callers for the same Connection share one in-flight refresh + respawn.
 */
-async function refreshConnection(apiClient, accountIdentifier, clientId, clientSecret) {
+async function refreshConnection(apiClient, accountIdentifier) {
 	const existing = inFlightRefreshByConnection.get(accountIdentifier);
 	if (existing) return existing;
 	const promise = (async () => {
@@ -136,9 +558,16 @@ async function refreshConnection(apiClient, accountIdentifier, clientId, clientS
 			if (!conn) throw new Error(`refreshAtlassianAccountToken succeeded for ${accountIdentifier} but no in-memory Connection bookkeeping exists`);
 			const nextLive = /* @__PURE__ */ new Set();
 			for (const intended of conn.intendedSites) {
+				if (cloudOwners.get(intended.id) !== accountIdentifier) {
+					log(`Refusing refresh respawn for an unowned selector on Connection ${connectionLogId(accountIdentifier)}`);
+					continue;
+				}
 				const old = sites.get(intended.id);
 				try {
-					const newChild = await spawnChild(accessToken, intended.id, clientId, clientSecret);
+					const newChild = await spawnChild(accessToken, intended.id);
+					await ensureChildToolCatalog(newChild, true).catch((error) => {
+						log(`Could not refresh the Atlassian tool catalog: ${safeErrorMessage(error, [accessToken])}`);
+					});
 					sites.set(intended.id, {
 						cloudId: intended.id,
 						siteName: intended.name,
@@ -147,11 +576,10 @@ async function refreshConnection(apiClient, accountIdentifier, clientId, clientS
 						client: newChild
 					});
 					nextLive.add(intended.id);
-					upsertSiteSummary({
+					upsertSiteSummary(accountIdentifier, {
 						cloudId: intended.id,
 						siteName: intended.name,
 						siteUrl: intended.url,
-						ownerAccountIdentifier: accountIdentifier,
 						ownerDisplayName: conn.displayName,
 						connectedAt: conn.connectedAt,
 						connected: true
@@ -160,19 +588,18 @@ async function refreshConnection(apiClient, accountIdentifier, clientId, clientS
 						await old.client.close();
 					} catch {}
 				} catch (spawnErr) {
-					const message = spawnErr instanceof Error ? spawnErr.message : String(spawnErr);
-					log(`Token refresh succeeded for Connection ${accountIdentifier} but re-spawn failed for cloudId ${intended.id}: ${message} — evicting stale child`);
+					const message = safeErrorMessage(spawnErr, [accessToken, conn.accessToken]);
+					log(`Token refresh succeeded for Connection ${connectionLogId(accountIdentifier)} but a child re-spawn failed: ${message} — evicting stale child`);
 					if (old) {
 						sites.delete(intended.id);
 						try {
 							await old.client.close();
 						} catch {}
 					}
-					upsertSiteSummary({
+					upsertSiteSummary(accountIdentifier, {
 						cloudId: intended.id,
 						siteName: intended.name,
 						siteUrl: intended.url,
-						ownerAccountIdentifier: accountIdentifier,
 						ownerDisplayName: conn.displayName,
 						connectedAt: conn.connectedAt,
 						connected: false,
@@ -190,58 +617,31 @@ async function refreshConnection(apiClient, accountIdentifier, clientId, clientS
 	inFlightRefreshByConnection.set(accountIdentifier, promise);
 	return promise;
 }
-function scheduleRefresh(apiClient, clientId, clientSecret) {
+function scheduleRefresh(apiClient, delayMs = REFRESH_INTERVAL_MS) {
 	if (refreshTimer) clearTimeout(refreshTimer);
 	refreshTimer = setTimeout(() => {
 		(async () => {
 			const ids = Array.from(connections.keys());
 			if (ids.length === 0) {
-				refreshTimer = setTimeout(() => {
-					scheduleRefresh(apiClient, clientId, clientSecret);
-				}, REFRESH_INTERVAL_MS);
+				scheduleRefresh(apiClient);
 				return;
 			}
 			log(`Refreshing Atlassian access tokens across ${String(ids.length)} Connection(s)...`);
 			let anyFailed = false;
 			for (const id of ids) try {
-				await refreshConnection(apiClient, id, clientId, clientSecret);
+				await refreshConnection(apiClient, id);
 			} catch (err) {
 				anyFailed = true;
-				log(`Token refresh failed for Connection ${id}: ${err instanceof Error ? err.message : String(err)}`);
+				const connection = connections.get(id);
+				log(`Token refresh failed for Connection ${connectionLogId(id)}: ${safeErrorMessage(err, connection ? [connection.accessToken] : [])}`);
 			}
-			refreshTimer = setTimeout(() => {
-				scheduleRefresh(apiClient, clientId, clientSecret);
-			}, anyFailed ? REFRESH_RETRY_MS : REFRESH_INTERVAL_MS);
-		})();
-	}, REFRESH_INTERVAL_MS);
-}
-/**
-* Inject a required `cloudId` string property into a child tool's
-* inputSchema. The proxy strips this arg before forwarding to the
-* matching child server.
-*/
-function injectCloudIdSelector(tool) {
-	const original = tool.inputSchema ?? {};
-	const originalProperties = original.properties ?? {};
-	const originalRequired = Array.isArray(original.required) ? original.required : [];
-	const injectedProperties = {
-		...originalProperties,
-		cloudId: {
-			type: "string",
-			description: "Atlassian Cloud site ID — use the value from atlassian_list_accounts to pick which connected site (Jira instance / Confluence instance) this call should target. One OAuth user may have access to multiple sites."
-		}
-	};
-	const injectedRequired = originalRequired.includes("cloudId") ? originalRequired : ["cloudId", ...originalRequired];
-	return {
-		name: tool.name,
-		description: tool.description,
-		inputSchema: {
-			...original,
-			type: original.type ?? "object",
-			properties: injectedProperties,
-			required: injectedRequired
-		}
-	};
+			scheduleRefresh(apiClient, anyFailed ? REFRESH_RETRY_MS : REFRESH_INTERVAL_MS);
+		})().catch((error) => {
+			log(`Scheduled refresh loop failed: ${safeErrorMessage(error)}`);
+			scheduleRefresh(apiClient, REFRESH_RETRY_MS);
+		});
+	}, delayMs);
+	refreshTimer.unref();
 }
 async function main() {
 	const config = resolveConfig();
@@ -250,141 +650,140 @@ async function main() {
 		apiUrl: config.apiUrl
 	});
 	const { accounts } = await apiClient.getAtlassianAccounts();
+	if (accounts.length > 50) throw new Error(`Connect returned more than ${String(50)} Atlassian Connections`);
 	if (accounts.length === 0) log("No Atlassian Connections found — proxy will start with atlassian_list_accounts and atlassian_check_connection only");
-	let sharedClientId = "";
-	let sharedClientSecret = "";
-	for (const acct of accounts) if (acct.clientId && acct.clientSecret) {
-		sharedClientId = acct.clientId;
-		sharedClientSecret = acct.clientSecret;
-		break;
-	}
+	let totalSites = 0;
 	for (const acct of accounts) {
-		const intendedSitesForAcct = acct.availableSites.length > 0 ? acct.availableSites.map((s) => ({
-			id: s.id,
-			name: s.name,
-			url: s.url
-		})) : acct.cloudId ? [{
-			id: acct.cloudId,
-			name: acct.siteName,
-			url: acct.siteUrl
-		}] : [];
-		if (!acct.accessToken) {
-			log(`Skipping Connection ${acct.accountIdentifier} — no access token`);
-			for (const site of intendedSitesForAcct) upsertSiteSummary({
-				cloudId: site.id,
-				siteName: site.name,
-				siteUrl: site.url,
-				ownerAccountIdentifier: acct.accountIdentifier,
-				ownerDisplayName: acct.displayName,
-				connectedAt: acct.connectedAt,
-				connected: false,
-				reason: "missing_access_token"
-			});
+		let accountIdentifier;
+		let displayName;
+		let connectedAt;
+		let intendedSitesForAcct;
+		try {
+			accountIdentifier = validateAccountIdentifier(acct.accountIdentifier);
+			displayName = acct.displayName === null ? null : validateDisplayName(acct.displayName);
+			connectedAt = validateConnectedAt(acct.connectedAt);
+			const rawSites = acct.availableSites.length > 0 ? acct.availableSites : acct.cloudId && acct.siteName && acct.siteUrl ? [{
+				id: acct.cloudId,
+				name: acct.siteName,
+				url: acct.siteUrl
+			}] : [];
+			if (rawSites.length > 100) throw new Error(`Connection exceeds ${String(100)} accessible sites`);
+			intendedSitesForAcct = rawSites.map((site) => ({
+				id: validateCloudId(site.id),
+				name: validateSiteName(site.name),
+				url: validateSiteUrl(site.url)
+			}));
+			totalSites += intendedSitesForAcct.length;
+			if (totalSites > 250) throw new Error(`Connect returned more than ${String(250)} Atlassian sites`);
+		} catch (error) {
+			log(`Skipping invalid Atlassian Connection metadata: ${safeErrorMessage(error, [acct.accessToken, acct.clientSecret])}`);
 			continue;
 		}
-		if (connections.has(acct.accountIdentifier)) {
-			log(`Duplicate accountIdentifier ${acct.accountIdentifier} returned by getAtlassianAccounts() — keeping the first cached Connection`);
-			for (const site of intendedSitesForAcct) upsertSiteSummary({
-				cloudId: site.id,
-				siteName: site.name,
-				siteUrl: site.url,
-				ownerAccountIdentifier: acct.accountIdentifier,
-				ownerDisplayName: acct.displayName,
-				connectedAt: acct.connectedAt,
-				connected: false,
-				reason: "duplicate_accountIdentifier"
-			});
+		if (connections.has(accountIdentifier)) {
+			log(`Duplicate Atlassian Connection ${connectionLogId(accountIdentifier)} returned by Connect — keeping the first`);
 			continue;
 		}
+		const connectionEntry = {
+			accountIdentifier,
+			displayName,
+			connectedAt,
+			accessToken: acct.accessToken,
+			intendedSites: [],
+			liveCloudIds: /* @__PURE__ */ new Set()
+		};
+		connections.set(accountIdentifier, connectionEntry);
 		if (intendedSitesForAcct.length === 0) {
-			log(`Connection ${acct.accountIdentifier} has no accessible Cloud sites — skipping (the agent will see this account in atlassian_list_accounts as connected: false)`);
-			upsertSiteSummary({
-				cloudId: `__no_sites__:${acct.accountIdentifier}`,
-				siteName: acct.displayName ?? acct.accountIdentifier,
+			log(`Atlassian Connection ${connectionLogId(accountIdentifier)} has no accessible Cloud sites`);
+			upsertSiteSummary(accountIdentifier, {
+				cloudId: null,
+				siteName: displayName ?? "Atlassian account",
 				siteUrl: "",
-				ownerAccountIdentifier: acct.accountIdentifier,
-				ownerDisplayName: acct.displayName,
-				connectedAt: acct.connectedAt,
+				ownerDisplayName: displayName,
+				connectedAt,
 				connected: false,
 				reason: "no_accessible_sites"
 			});
 			continue;
 		}
-		const connectionEntry = {
-			accountIdentifier: acct.accountIdentifier,
-			displayName: acct.displayName,
-			connectedAt: acct.connectedAt,
-			accessToken: acct.accessToken,
-			intendedSites: intendedSitesForAcct,
-			liveCloudIds: /* @__PURE__ */ new Set()
-		};
 		for (const site of intendedSitesForAcct) {
-			if (sites.has(site.id)) {
-				log(`Duplicate cloudId ${site.id} across Atlassian Connections — keeping the first cached site`);
-				upsertSiteSummary({
+			if (!claimCloudId(cloudOwners, site.id, accountIdentifier)) {
+				log(`Duplicate Atlassian cloudId rejected for Connection ${connectionLogId(accountIdentifier)} — keeping the first owner`);
+				upsertSiteSummary(accountIdentifier, {
 					cloudId: site.id,
 					siteName: site.name,
 					siteUrl: site.url,
-					ownerAccountIdentifier: acct.accountIdentifier,
-					ownerDisplayName: acct.displayName,
-					connectedAt: acct.connectedAt,
+					ownerDisplayName: displayName,
+					connectedAt,
 					connected: false,
 					reason: "duplicate_cloudId"
 				});
 				continue;
 			}
+			connectionEntry.intendedSites.push(site);
+			if (!acct.accessToken) {
+				upsertSiteSummary(accountIdentifier, {
+					cloudId: site.id,
+					siteName: site.name,
+					siteUrl: site.url,
+					ownerDisplayName: displayName,
+					connectedAt,
+					connected: false,
+					reason: "missing_access_token"
+				});
+				continue;
+			}
 			try {
-				const child = await spawnChild(acct.accessToken, site.id, acct.clientId || sharedClientId, acct.clientSecret || sharedClientSecret);
+				const child = await spawnChild(acct.accessToken, site.id);
 				sites.set(site.id, {
 					cloudId: site.id,
 					siteName: site.name,
 					siteUrl: site.url,
-					ownerAccountIdentifier: acct.accountIdentifier,
+					ownerAccountIdentifier: accountIdentifier,
 					client: child
 				});
 				connectionEntry.liveCloudIds.add(site.id);
-				upsertSiteSummary({
+				upsertSiteSummary(accountIdentifier, {
 					cloudId: site.id,
 					siteName: site.name,
 					siteUrl: site.url,
-					ownerAccountIdentifier: acct.accountIdentifier,
-					ownerDisplayName: acct.displayName,
-					connectedAt: acct.connectedAt,
+					ownerDisplayName: displayName,
+					connectedAt,
 					connected: true
 				});
-				log(`Spawned child for site ${site.id} (${site.name}) under Connection ${acct.accountIdentifier}`);
+				log(`Spawned Atlassian child for Connection ${connectionLogId(accountIdentifier)}`);
 			} catch (err) {
-				const message = err instanceof Error ? err.message : String(err);
-				log(`Failed to spawn child for site ${site.id} (${site.name}) under Connection ${acct.accountIdentifier}: ${message}`);
-				upsertSiteSummary({
+				const message = safeErrorMessage(err, [acct.accessToken, acct.clientSecret]);
+				log(`Failed to spawn Atlassian child for Connection ${connectionLogId(accountIdentifier)}: ${message}`);
+				upsertSiteSummary(accountIdentifier, {
 					cloudId: site.id,
 					siteName: site.name,
 					siteUrl: site.url,
-					ownerAccountIdentifier: acct.accountIdentifier,
-					ownerDisplayName: acct.displayName,
-					connectedAt: acct.connectedAt,
+					ownerDisplayName: displayName,
+					connectedAt,
 					connected: false,
 					reason: `spawn_failed: ${message}`
 				});
 			}
 		}
-		connections.set(acct.accountIdentifier, connectionEntry);
 	}
 	const firstSite = sites.values().next().value;
-	if (firstSite) {
-		const { tools } = await firstSite.client.listTools();
-		cachedTools = tools.map(injectCloudIdSelector);
-		log(`Child MCP server provides ${String(cachedTools.length)} tools (cloudId selector injected)`);
-	} else {
+	if (firstSite) await ensureChildToolCatalog(firstSite.client, false);
+	else {
 		cachedTools = [];
 		log("No child server available — only atlassian_list_accounts, atlassian_check_connection, and atlassian_refresh_token will be exposed");
 	}
 	cachedTools.push({
 		name: "atlassian_list_accounts",
-		description: "List the Atlassian Cloud sites the agent has connected. Each entry pairs a `cloudId` (the selector value to pass on every other Atlassian tool) with its owning OAuth identity (`ownerAccountIdentifier`, an email). One OAuth user may own multiple sites — they share an access token but each has a distinct cloudId.",
+		description: "List the Atlassian Cloud sites the agent has connected. Each connected entry provides the cloudId selector to pass to other Atlassian tools. One OAuth user may own multiple sites.",
 		inputSchema: {
 			type: "object",
-			properties: {}
+			properties: {},
+			additionalProperties: false
+		},
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: false
 		}
 	});
 	cachedTools.push({
@@ -396,7 +795,13 @@ async function main() {
 				type: "string",
 				description: "Atlassian Cloud site ID — use the value from atlassian_list_accounts."
 			} },
-			required: ["cloudId"]
+			required: ["cloudId"],
+			additionalProperties: false
+		},
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: true
 		}
 	});
 	cachedTools.push({
@@ -408,7 +813,14 @@ async function main() {
 				type: "string",
 				description: "Atlassian Cloud site ID — used to look up the owning Connection. Use the value from atlassian_list_accounts."
 			} },
-			required: ["cloudId"]
+			required: ["cloudId"],
+			additionalProperties: false
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false,
+			openWorldHint: true
 		}
 	});
 	assertPatternA(cachedTools.map((t) => ({
@@ -420,75 +832,81 @@ async function main() {
 	});
 	const proxy = new Server({
 		name: "atlassian-mcp-proxy",
-		version: "0.1.0"
-	}, { capabilities: { tools: {} } });
+		version: packageMetadata.version
+	}, { capabilities: { tools: { listChanged: true } } });
+	proxyServer = proxy;
 	proxy.setRequestHandler(ListToolsRequestSchema, () => ({ tools: cachedTools }));
 	proxy.setRequestHandler(CallToolRequestSchema, async (request) => {
 		const { name, arguments: args } = request.params;
-		const argMap = args ?? {};
-		if (name === "atlassian_list_accounts") return { content: [{
-			type: "text",
-			text: JSON.stringify({ sites: allSitesSnapshot }, null, 2)
-		}] };
-		if (name === "atlassian_check_connection") try {
-			const site = resolveSite(typeof argMap.cloudId === "string" ? argMap.cloudId : void 0);
-			const conn = connections.get(site.ownerAccountIdentifier);
-			if (!conn) return {
+		let argMap;
+		try {
+			argMap = assertBoundedToolArguments(args ?? {});
+		} catch (error) {
+			return {
 				content: [{
 					type: "text",
-					text: JSON.stringify({
-						cloudId: site.cloudId,
-						connected: false,
-						error: "Owning Connection not found in proxy bookkeeping"
-					})
+					text: JSON.stringify({ error: safeErrorMessage(error) })
 				}],
 				isError: true
 			};
-			const response = await fetch("https://api.atlassian.com/me", { headers: {
-				Authorization: `Bearer ${conn.accessToken}`,
-				Accept: "application/json"
-			} });
-			if (!response.ok) return {
+		}
+		if (name === "atlassian_list_accounts") {
+			if (Object.keys(argMap).length > 0) return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: "atlassian_list_accounts accepts no arguments" })
+				}],
+				isError: true
+			};
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({ sites: allSitesSnapshot }, null, 2)
+			}] };
+		}
+		if (name === "atlassian_check_connection") try {
+			if (Object.keys(argMap).some((key) => key !== "cloudId")) throw new Error("atlassian_check_connection accepts only cloudId");
+			const cloudId = typeof argMap.cloudId === "string" ? validateCloudId(argMap.cloudId) : void 0;
+			const conn = resolveConnectionForCloudId(cloudId);
+			const site = cloudId === void 0 ? void 0 : sites.get(cloudId);
+			const check = await checkAtlassianConnection(conn.accessToken);
+			if (!check.ok) return {
 				content: [{
 					type: "text",
 					text: JSON.stringify({
-						cloudId: site.cloudId,
+						cloudId,
 						connected: false,
-						status: response.status,
-						error: "Token may have been revoked or expired. Try atlassian_refresh_token for this cloudId; if that fails ask the user to reconnect this Atlassian account."
+						status: check.status,
+						error: "Token may have expired or been revoked. Try atlassian_refresh_token; if that fails ask the user to reconnect this account."
 					})
 				}],
 				isError: true
 			};
-			const user = await response.json();
 			return { content: [{
 				type: "text",
 				text: JSON.stringify({
-					cloudId: site.cloudId,
-					siteName: site.siteName,
-					siteUrl: site.siteUrl,
-					ownerAccountIdentifier: site.ownerAccountIdentifier,
-					connected: true,
-					user
+					cloudId,
+					siteName: site?.siteName,
+					siteUrl: site?.siteUrl,
+					connected: true
 				})
 			}] };
 		} catch (err) {
 			return {
 				content: [{
 					type: "text",
-					text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+					text: JSON.stringify({ error: safeErrorMessage(err) })
 				}],
 				isError: true
 			};
 		}
 		if (name === "atlassian_refresh_token") try {
-			const site = resolveSite(typeof argMap.cloudId === "string" ? argMap.cloudId : void 0);
-			await refreshConnection(apiClient, site.ownerAccountIdentifier, sharedClientId, sharedClientSecret);
+			if (Object.keys(argMap).some((key) => key !== "cloudId")) throw new Error("atlassian_refresh_token accepts only cloudId");
+			const cloudId = typeof argMap.cloudId === "string" ? validateCloudId(argMap.cloudId) : void 0;
+			await refreshConnection(apiClient, resolveConnectionForCloudId(cloudId).accountIdentifier);
 			return { content: [{
 				type: "text",
 				text: JSON.stringify({
-					cloudId: site.cloudId,
-					ownerAccountIdentifier: site.ownerAccountIdentifier,
+					cloudId,
 					refreshed: true
 				})
 			}] };
@@ -496,30 +914,41 @@ async function main() {
 			return {
 				content: [{
 					type: "text",
-					text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+					text: JSON.stringify({ error: safeErrorMessage(err) })
 				}],
 				isError: true
 			};
 		}
+		if (!cachedTools.some((tool) => tool.name === name)) return {
+			content: [{
+				type: "text",
+				text: JSON.stringify({ error: "Unknown Atlassian tool" })
+			}],
+			isError: true
+		};
 		let site;
+		let forwarded;
 		try {
 			site = resolveSite(typeof argMap.cloudId === "string" ? argMap.cloudId : void 0);
+			forwarded = prepareForwardedArguments(name, argMap);
 		} catch (err) {
 			return {
 				content: [{
 					type: "text",
-					text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+					text: JSON.stringify({ error: safeErrorMessage(err) })
 				}],
 				isError: true
 			};
 		}
-		const { cloudId: _ignored, ...forwarded } = argMap;
 		let result;
 		try {
-			result = await site.client.callTool({
+			result = assertBoundedToolResult(await site.client.callTool({
 				name,
 				arguments: forwarded
-			});
+			}, void 0, {
+				timeout: 12e4,
+				signal: AbortSignal.timeout(12e4)
+			}));
 		} catch (err) {
 			return {
 				content: [{
@@ -527,24 +956,39 @@ async function main() {
 					text: JSON.stringify({
 						cloudId: site.cloudId,
 						tool: name,
-						error: err instanceof Error ? err.message : String(err)
+						error: safeErrorMessage(err, [connections.get(site.ownerAccountIdentifier)?.accessToken ?? ""])
 					})
 				}],
 				isError: true
 			};
 		}
 		if (result.isError) {
-			const errorText = result.content.map((c) => c.text ?? "").join("\n");
+			const errorText = extractToolErrorText(result);
 			if (errorText.includes("401") || errorText.toLowerCase().includes("unauthorized")) {
-				log(`401 from cloudId ${site.cloudId} (owner ${site.ownerAccountIdentifier}), refreshing and retrying...`);
+				log(`Atlassian child returned 401 for Connection ${connectionLogId(site.ownerAccountIdentifier)}; refreshing once`);
 				try {
-					await refreshConnection(apiClient, site.ownerAccountIdentifier, sharedClientId, sharedClientSecret);
+					await refreshConnection(apiClient, site.ownerAccountIdentifier);
 					const refreshed = resolveSite(site.cloudId);
 					try {
-						return await refreshed.client.callTool({
+						const retryResult = assertBoundedToolResult(await refreshed.client.callTool({
 							name,
 							arguments: forwarded
-						});
+						}, void 0, {
+							timeout: 12e4,
+							signal: AbortSignal.timeout(12e4)
+						}));
+						if (retryResult.isError) return {
+							content: [{
+								type: "text",
+								text: JSON.stringify({
+									cloudId: site.cloudId,
+									tool: name,
+									error: safeErrorMessage(extractToolErrorText(retryResult), [connections.get(site.ownerAccountIdentifier)?.accessToken ?? ""])
+								})
+							}],
+							isError: true
+						};
+						return retryResult;
 					} catch (retryErr) {
 						return {
 							content: [{
@@ -552,7 +996,7 @@ async function main() {
 								text: JSON.stringify({
 									cloudId: site.cloudId,
 									tool: name,
-									error: `Retry after refresh failed: ${retryErr instanceof Error ? retryErr.message : String(retryErr)}`
+									error: `Retry after refresh failed: ${safeErrorMessage(retryErr, [connections.get(site.ownerAccountIdentifier)?.accessToken ?? ""])}`
 								})
 							}],
 							isError: true
@@ -564,35 +1008,46 @@ async function main() {
 							type: "text",
 							text: JSON.stringify({
 								cloudId: site.cloudId,
-								ownerAccountIdentifier: site.ownerAccountIdentifier,
-								error: `Token refresh failed: ${refreshErr instanceof Error ? refreshErr.message : String(refreshErr)}`
+								error: `Token refresh failed: ${safeErrorMessage(refreshErr)}`
 							})
 						}],
 						isError: true
 					};
 				}
 			}
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						cloudId: site.cloudId,
+						tool: name,
+						error: safeErrorMessage(errorText || "Atlassian tool failed", [connections.get(site.ownerAccountIdentifier)?.accessToken ?? ""])
+					})
+				}],
+				isError: true
+			};
 		}
 		return result;
 	});
-	if (sharedClientId && sharedClientSecret) scheduleRefresh(apiClient, sharedClientId, sharedClientSecret);
-	else if (connections.size > 0) log("No shared OAuth client credentials available — scheduled refresh disabled. Refresh will be possible per call via the atlassian_refresh_token tool, but only if the API returns 401 explicitly.");
+	if (connections.size > 0) scheduleRefresh(apiClient);
 	const transport = new StdioServerTransport();
 	await proxy.connect(transport);
 	log(`Proxy running with ${String(sites.size)} site(s) across ${String(connections.size)} Connection(s) and Pattern A selector enforcement`);
 }
-for (const signal of ["SIGTERM", "SIGINT"]) process.on(signal, () => {
+let shutdownPromise = null;
+function shutdown(exitCode) {
+	if (shutdownPromise !== null) return;
 	if (refreshTimer) clearTimeout(refreshTimer);
-	killAllChildren().then(() => {
-		process.exit(0);
+	shutdownPromise = killAllChildren().finally(() => {
+		process.exit(exitCode);
 	});
+}
+for (const signal of ["SIGTERM", "SIGINT"]) process.once(signal, () => {
+	shutdown(0);
 });
 main().catch((err) => {
-	log(`Fatal: ${err instanceof Error ? err.message : String(err)}`);
-	if (refreshTimer) clearTimeout(refreshTimer);
-	killAllChildren().finally(() => {
-		process.exit(1);
-	});
+	log(`Fatal: ${safeErrorMessage(err, Array.from(connections.values(), (connection) => connection.accessToken))}`);
+	shutdown(1);
 });
 //#endregion
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/atlassian-mcp",
-  "version": "0.3.17",
+  "version": "0.3.19",
   "description": "Atlassian MCP proxy server — bridges sooperset/mcp-atlassian with Alfe OAuth credentials (Pattern A multi-site)",
   "type": "module",
   "main": "./dist/server.js",
@@ -18,9 +18,9 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": ">=1.24.0",
-    "@alfe.ai/config": "0.3.0",
-    "@alfe.ai/agent-api-client": "0.13.0",
-    "@alfe.ai/mcp-bundler": "0.4.0"
+    "@alfe.ai/config": "0.4.1",
+    "@alfe.ai/agent-api-client": "0.15.0",
+    "@alfe.ai/mcp-bundler": "0.4.1"
   },
   "license": "UNLICENSED",
   "homepage": "https://alfe.ai",
@@ -36,6 +36,7 @@
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",
+    "test": "vitest run",
     "typecheck": "tsc --noEmit",
     "lint": "eslint ."
   }