@alfe.ai/atlassian-mcp 0.3.0

package/dist/server.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server.js

@@ -0,0 +1,598 @@
+#!/usr/bin/env node
+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
+/**
+* Atlassian MCP Proxy Server (Pattern A multi-site)
+*
+* A thin proxy that fans out to one `sooperset/mcp-atlassian` child
+* process per (OAuth Connection × Atlassian Cloud site). Every
+* credential-touching tool requires the LLM to pass a `cloudId` selector
+* arg; the proxy strips that arg, dispatches to the right child, and
+* returns the result.
+*
+* Pattern A locked in PR 7-deferred slice 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 (more involved than the Notion / Xero / GitHub proxies
+* because Atlassian is multi-site PER OAuth user):
+*
+*   OpenClaw ←(stdio)→ this proxy ←(stdio fan-out)→ N × `uvx mcp-atlassian`
+*
+*   Each Connection (OAuth user) -> 1 access token + N accessible Cloud
+*   sites. We spawn one child per (Connection, cloudId), all sharing
+*   the Connection's access token. Refreshing one Connection rotates
+*   the access token for every cloudId it owns, so the proxy fans the
+*   new token out to every child the Connection spawned.
+*
+* Token refresh is per-Connection (NOT per-cloudId): the OAuth user has
+* one refresh token that covers every site they can reach. Atlassian
+* rotates refresh tokens — server-side persistence is handled by the
+* /accounts/{accountIdentifier}/refresh endpoint.
+*
+* Atlassian access tokens are short-lived (~1 hour). The scheduled
+* refresh walks every Connection on a 45-minute cadence to stay ahead
+* of expiry.
+*
+* Uses the low-level Server class (not McpServer) because child tools
+* return JSON Schema objects — McpServer.registerTool requires Zod.
+*/
+/** 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();
+/**
+* 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 = [];
+let cachedTools = [];
+let refreshTimer = null;
+/**
+* Collapse concurrent refreshes on a per-Connection basis. A burst of
+* 401s across the same Connection's sites share one in-flight refresh.
+*/
+const inFlightRefreshByConnection = /* @__PURE__ */ new Map();
+const REFRESH_INTERVAL_MS = 2700 * 1e3;
+const REFRESH_RETRY_MS = 60 * 1e3;
+/**
+* Pin the child mcp-atlassian version. The package is distributed via
+* PyPI / uvx, so `uvx mcp-atlassian@<version>` resolves a pinned wheel.
+* `package.json` doesn't have a direct dep on the Python package, so
+* 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
+* 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 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);
+	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.`);
+	}
+	return site;
+}
+async function spawnChild(accessToken, cloudId, clientId, clientSecret) {
+	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
+		}
+	});
+	const client = new Client({
+		name: "atlassian-mcp-proxy",
+		version: "0.1.0"
+	});
+	await client.connect(transport);
+	return client;
+}
+async function killAllChildren() {
+	for (const site of sites.values()) try {
+		await site.client.close();
+	} catch {}
+	sites.clear();
+}
+/**
+* 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) {
+	const existing = inFlightRefreshByConnection.get(accountIdentifier);
+	if (existing) return existing;
+	const promise = (async () => {
+		try {
+			const { accessToken } = await apiClient.refreshAtlassianAccountToken(accountIdentifier);
+			const conn = connections.get(accountIdentifier);
+			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) {
+				const old = sites.get(intended.id);
+				try {
+					const newChild = await spawnChild(accessToken, intended.id, clientId, clientSecret);
+					sites.set(intended.id, {
+						cloudId: intended.id,
+						siteName: intended.name,
+						siteUrl: intended.url,
+						ownerAccountIdentifier: accountIdentifier,
+						client: newChild
+					});
+					nextLive.add(intended.id);
+					upsertSiteSummary({
+						cloudId: intended.id,
+						siteName: intended.name,
+						siteUrl: intended.url,
+						ownerAccountIdentifier: accountIdentifier,
+						ownerDisplayName: conn.displayName,
+						connectedAt: conn.connectedAt,
+						connected: true
+					});
+					if (old) try {
+						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`);
+					if (old) {
+						sites.delete(intended.id);
+						try {
+							await old.client.close();
+						} catch {}
+					}
+					upsertSiteSummary({
+						cloudId: intended.id,
+						siteName: intended.name,
+						siteUrl: intended.url,
+						ownerAccountIdentifier: accountIdentifier,
+						ownerDisplayName: conn.displayName,
+						connectedAt: conn.connectedAt,
+						connected: false,
+						reason: `respawn_failed_after_refresh: ${message}`
+					});
+				}
+			}
+			conn.accessToken = accessToken;
+			conn.liveCloudIds = nextLive;
+			return accessToken;
+		} finally {
+			inFlightRefreshByConnection.delete(accountIdentifier);
+		}
+	})();
+	inFlightRefreshByConnection.set(accountIdentifier, promise);
+	return promise;
+}
+function scheduleRefresh(apiClient, clientId, clientSecret) {
+	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);
+				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);
+			} catch (err) {
+				anyFailed = true;
+				log(`Token refresh failed for Connection ${id}: ${err instanceof Error ? err.message : String(err)}`);
+			}
+			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
+		}
+	};
+}
+async function main() {
+	const config = resolveConfig();
+	const apiClient = new AgentApiClient({
+		apiKey: config.apiKey,
+		apiUrl: config.apiUrl
+	});
+	const { accounts } = await apiClient.getAtlassianAccounts();
+	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;
+	}
+	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"
+			});
+			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"
+			});
+			continue;
+		}
+		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,
+				siteUrl: "",
+				ownerAccountIdentifier: acct.accountIdentifier,
+				ownerDisplayName: acct.displayName,
+				connectedAt: acct.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({
+					cloudId: site.id,
+					siteName: site.name,
+					siteUrl: site.url,
+					ownerAccountIdentifier: acct.accountIdentifier,
+					ownerDisplayName: acct.displayName,
+					connectedAt: acct.connectedAt,
+					connected: false,
+					reason: "duplicate_cloudId"
+				});
+				continue;
+			}
+			try {
+				const child = await spawnChild(acct.accessToken, site.id, acct.clientId || sharedClientId, acct.clientSecret || sharedClientSecret);
+				sites.set(site.id, {
+					cloudId: site.id,
+					siteName: site.name,
+					siteUrl: site.url,
+					ownerAccountIdentifier: acct.accountIdentifier,
+					client: child
+				});
+				connectionEntry.liveCloudIds.add(site.id);
+				upsertSiteSummary({
+					cloudId: site.id,
+					siteName: site.name,
+					siteUrl: site.url,
+					ownerAccountIdentifier: acct.accountIdentifier,
+					ownerDisplayName: acct.displayName,
+					connectedAt: acct.connectedAt,
+					connected: true
+				});
+				log(`Spawned child for site ${site.id} (${site.name}) under Connection ${acct.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({
+					cloudId: site.id,
+					siteName: site.name,
+					siteUrl: site.url,
+					ownerAccountIdentifier: acct.accountIdentifier,
+					ownerDisplayName: acct.displayName,
+					connectedAt: acct.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 {
+		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.",
+		inputSchema: {
+			type: "object",
+			properties: {}
+		}
+	});
+	cachedTools.push({
+		name: "atlassian_check_connection",
+		description: "Verify the Atlassian OAuth connection for a specific cloudId is still valid. Use this if Atlassian API calls are failing with authentication errors. The check probes /me with the access token bound to the cloudId's owning Connection.",
+		inputSchema: {
+			type: "object",
+			properties: { cloudId: {
+				type: "string",
+				description: "Atlassian Cloud site ID — use the value from atlassian_list_accounts."
+			} },
+			required: ["cloudId"]
+		}
+	});
+	cachedTools.push({
+		name: "atlassian_refresh_token",
+		description: "Force-refresh the Atlassian OAuth access token for the Connection that owns a given cloudId. One refresh rotates the access token for every site that Connection can reach. Use this if API calls are failing with 401.",
+		inputSchema: {
+			type: "object",
+			properties: { cloudId: {
+				type: "string",
+				description: "Atlassian Cloud site ID — used to look up the owning Connection. Use the value from atlassian_list_accounts."
+			} },
+			required: ["cloudId"]
+		}
+	});
+	assertPatternA(cachedTools.map((t) => ({
+		name: t.name,
+		parameters: t.inputSchema
+	})), {
+		selector: "cloudId",
+		exempt: ["atlassian_list_accounts"]
+	});
+	const proxy = new Server({
+		name: "atlassian-mcp-proxy",
+		version: "0.1.0"
+	}, { capabilities: { tools: {} } });
+	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 {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						cloudId: site.cloudId,
+						connected: false,
+						error: "Owning Connection not found in proxy bookkeeping"
+					})
+				}],
+				isError: true
+			};
+			const response = await fetch("https://api.atlassian.com/me", { headers: {
+				Authorization: `Bearer ${conn.accessToken}`,
+				Accept: "application/json"
+			} });
+			if (!response.ok) return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						cloudId: site.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."
+					})
+				}],
+				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
+				})
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: err instanceof Error ? err.message : String(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);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					cloudId: site.cloudId,
+					ownerAccountIdentifier: site.ownerAccountIdentifier,
+					refreshed: true
+				})
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+				}],
+				isError: true
+			};
+		}
+		let site;
+		try {
+			site = resolveSite(typeof argMap.cloudId === "string" ? argMap.cloudId : void 0);
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+				}],
+				isError: true
+			};
+		}
+		const { cloudId: _ignored, ...forwarded } = argMap;
+		let result;
+		try {
+			result = await site.client.callTool({
+				name,
+				arguments: forwarded
+			});
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						cloudId: site.cloudId,
+						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 cloudId ${site.cloudId} (owner ${site.ownerAccountIdentifier}), refreshing and retrying...`);
+				try {
+					await refreshConnection(apiClient, site.ownerAccountIdentifier, sharedClientId, sharedClientSecret);
+					const refreshed = resolveSite(site.cloudId);
+					try {
+						return await refreshed.client.callTool({
+							name,
+							arguments: forwarded
+						});
+					} catch (retryErr) {
+						return {
+							content: [{
+								type: "text",
+								text: JSON.stringify({
+									cloudId: site.cloudId,
+									tool: name,
+									error: `Retry after refresh failed: ${retryErr instanceof Error ? retryErr.message : String(retryErr)}`
+								})
+							}],
+							isError: true
+						};
+					}
+				} catch (refreshErr) {
+					return {
+						content: [{
+							type: "text",
+							text: JSON.stringify({
+								cloudId: site.cloudId,
+								ownerAccountIdentifier: site.ownerAccountIdentifier,
+								error: `Token refresh failed: ${refreshErr instanceof Error ? refreshErr.message : String(refreshErr)}`
+							})
+						}],
+						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.");
+	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, () => {
+	if (refreshTimer) clearTimeout(refreshTimer);
+	killAllChildren().then(() => {
+		process.exit(0);
+	});
+});
+main().catch((err) => {
+	log(`Fatal: ${err instanceof Error ? err.message : String(err)}`);
+	if (refreshTimer) clearTimeout(refreshTimer);
+	killAllChildren().finally(() => {
+		process.exit(1);
+	});
+});
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@alfe.ai/atlassian-mcp",
+  "version": "0.3.0",
+  "description": "Atlassian MCP proxy server — bridges sooperset/mcp-atlassian with Alfe OAuth credentials (Pattern A multi-site)",
+  "type": "module",
+  "main": "./dist/server.js",
+  "bin": {
+    "atlassian-mcp-proxy": "./dist/server.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": ">=1.24.0",
+    "@alfe.ai/config": "0.1.0",
+    "@alfe.ai/agent-api-client": "0.3.0",
+    "@alfe.ai/mcp-bundler": "0.2.1"
+  },
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint ."
+  }
+}