@mastra/factory 0.0.0-aggregate-trace-20261015182851

package/dist/integrations/platform/linear/integration.js

@@ -0,0 +1,754 @@
+import { PlatformApiClient, PlatformApiError, logPlatformInfo, logPlatformWarn, platformApiClientConfigFromEnv } from "../api-client.js";
+import { resolveLinearRules } from "../../linear/default-rules.js";
+import { attachLinearRules } from "../../linear/rules.js";
+import { attachLinearIssueReconciler } from "../../linear/issue-reconciler.js";
+import { linearIssueReconciliationEnabled, linearIssueReconciliationInterval } from "../../linear/reconciliation-config.js";
+import { buildLinearRoutes } from "../../linear/routes.js";
+import { buildLinearAgentTools } from "../../linear/agent-tools.js";
+import { PlatformLinearEventWorker } from "./event-worker.js";
+import { registerApiRoute } from "@mastra/core/server";
+//#region src/integrations/platform/linear/integration.ts
+const API_PREFIX = "/v1/server/linear";
+const PAGE_SIZE = 30;
+const MAX_REFERENCE_PAGES = 20;
+const MAX_COMMENT_PAGES = 20;
+const PLATFORM_MANAGED_CONNECTION_TOKEN = "platform-managed";
+function loose(c) {
+	return c;
+}
+function routeBaseUrl(ctx, requestUrl) {
+	return (ctx.baseUrl || new URL(requestUrl).origin).replace(/\/+$/, "");
+}
+var PlatformLinearIntegration = class {
+	id = "linear";
+	#client;
+	#endpointHost;
+	#projects;
+	#auth;
+	/**
+	* Per-instance workflow-state cache keyed by `${workspaceId}:${teamId}`. Scoped to the process
+	* lifetime; not shared across requests intentionally to keep failure modes simple (stale states
+	* clear on process restart). Populated lazily on first `updateIssue` per team.
+	*/
+	#workflowStatesByTeam = /* @__PURE__ */ new Map();
+	intake = {
+		resolveIntakeDispatch: (input) => this.#resolveIntakeDispatch(input),
+		listSources: async () => {
+			const [projectSources, teamSources] = await Promise.all([this.#listProjectSources(), this.#listTeamSources()]);
+			const projects = projectSources.map(({ workspace, project }) => ({
+				id: encodeSourceId(workspace.linearWorkspaceId, project.id),
+				name: project.name,
+				type: "project",
+				metadata: {
+					workspaceId: workspace.linearWorkspaceId,
+					workspaceName: workspace.linearWorkspaceName,
+					workspaceUrlKey: workspace.urlKey,
+					state: project.state,
+					teams: project.teams
+				}
+			}));
+			const teams = teamSources.map(({ workspace, team }) => ({
+				id: encodeTeamSourceId(workspace.linearWorkspaceId, team.id),
+				name: team.name,
+				type: "team",
+				metadata: {
+					workspaceId: workspace.linearWorkspaceId,
+					workspaceName: workspace.linearWorkspaceName,
+					workspaceUrlKey: workspace.urlKey,
+					teamKey: team.key
+				}
+			}));
+			return [...projects, ...teams];
+		},
+		listItems: async ({ sourceIds, attributionSourceIds, cursor }) => {
+			const result = await this.#listIssues(sourceIds, cursor, void 0, attributionSourceIds);
+			return {
+				items: result.issues.map(({ issue, sourceId, workspace }) => ({
+					source: {
+						type: "issue",
+						externalId: issue.id,
+						url: issue.url
+					},
+					sourceId,
+					title: issue.title,
+					status: issue.state.name,
+					labels: issue.labels.map((label) => label.name),
+					assignee: issue.assignee?.displayName ?? issue.assignee?.name ?? null,
+					createdAt: issue.createdAt,
+					updatedAt: issue.updatedAt,
+					metadata: {
+						identifier: issue.identifier,
+						workspaceId: workspace.linearWorkspaceId,
+						workspaceName: workspace.linearWorkspaceName,
+						projectId: issue.project?.id ?? null,
+						team: issue.team.key,
+						priority: issue.priorityLabel
+					}
+				})),
+				nextCursor: result.nextCursor
+			};
+		},
+		listIssues: async ({ connection, sourceIds, attributionSourceIds, labels, cursor }) => {
+			requireLinearConnection(connection);
+			const result = await this.#listIssues(sourceIds, cursor, labels, attributionSourceIds);
+			return {
+				issues: result.issues.map(({ issue, sourceId, workspace }) => ({
+					...parseIssue(issue, workspace.linearWorkspaceId),
+					sourceId
+				})),
+				nextCursor: result.nextCursor
+			};
+		},
+		getIssue: async ({ connection, sourceId, issueId }) => {
+			requireLinearConnection(connection);
+			const located = await this.#findIssue(sourceId, issueId);
+			if (!located) return null;
+			const comments = await this.#loadComments(located.workspaceId, issueId, located.issue.comments);
+			return parseIssueDetail(located.issue, comments, located.workspaceId);
+		},
+		createComment: async ({ connection, sourceId, issueId, body }) => {
+			requireLinearConnection(connection);
+			const workspaceId = await this.#resolveWorkspaceForIssue(sourceId, issueId);
+			if (!workspaceId) return null;
+			try {
+				const comment = await this.#client.request("POST", `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/issues/${encodeURIComponent(issueId)}/comments`, { body });
+				return {
+					id: comment.id,
+					url: comment.url
+				};
+			} catch (error) {
+				if (isNotFound(error)) return null;
+				throw error;
+			}
+		},
+		updateIssue: async (input) => {
+			requireLinearConnection(input.connection);
+			const located = await this.#findIssue(input.sourceId, input.issueId);
+			if (!located) return null;
+			const { workspaceId, issue } = located;
+			const target = input.state;
+			if (target.kind === "byType" && issue.state.type === target.stateType) return parseIssue(issue, workspaceId);
+			if (target.kind === "byName" && issue.state.name.toLowerCase() === target.name.toLowerCase()) return parseIssue(issue, workspaceId);
+			let states;
+			try {
+				states = await this.#listWorkflowStates(workspaceId, issue.team.id);
+			} catch (error) {
+				if (isNotFound(error)) {
+					logPlatformWarn("Platform Linear: workflow-states endpoint not available; skipping updateIssue.", {
+						workspaceId,
+						teamId: issue.team.id
+					});
+					return null;
+				}
+				throw error;
+			}
+			let matched;
+			if (target.kind === "byType") matched = states.slice().sort((a, b) => a.position - b.position).find((s) => s.type === target.stateType);
+			else {
+				const wanted = target.name.toLowerCase();
+				matched = states.find((s) => s.name.toLowerCase() === wanted);
+			}
+			if (!matched) {
+				logPlatformWarn("Platform Linear: no workflow state matched target; skipping updateIssue.", {
+					workspaceId,
+					teamId: issue.team.id,
+					target
+				});
+				return null;
+			}
+			try {
+				await this.#client.request("PATCH", `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/issues/${encodeURIComponent(input.issueId)}`, { stateId: matched.id });
+			} catch (error) {
+				if (isNotFound(error)) return null;
+				throw error;
+			}
+			const refreshed = await this.#findIssue(input.sourceId, input.issueId);
+			return refreshed ? parseIssue(refreshed.issue, refreshed.workspaceId) : null;
+		}
+	};
+	#rules;
+	get rules() {
+		return this.#rules;
+	}
+	constructor({ rules } = {}) {
+		this.#rules = resolveLinearRules(rules);
+		const config = platformApiClientConfigFromEnv();
+		this.#client = new PlatformApiClient(config);
+		this.#endpointHost = new URL(config.baseUrl).host;
+	}
+	get storage() {
+		const now = /* @__PURE__ */ new Date();
+		return {
+			integrationId: this.id,
+			connections: { get: async (orgId) => ({
+				id: `platform-linear:${orgId}`,
+				orgId,
+				userId: null,
+				data: {
+					accessToken: PLATFORM_MANAGED_CONNECTION_TOKEN,
+					refreshToken: null,
+					expiresAtMs: null,
+					scope: "read,comments:create",
+					workspaceName: null,
+					workspaceUrlKey: null
+				},
+				metadata: {},
+				createdAt: now,
+				updatedAt: now
+			}) }
+		};
+	}
+	get projects() {
+		if (!this.#projects) throw new Error("PlatformLinearIntegration projects storage has not been initialized.");
+		return this.#projects;
+	}
+	initialize({ projects, auth }) {
+		this.#projects = projects;
+		this.#auth = auth;
+		logPlatformInfo("Platform Linear integration initialized", { endpointHost: this.#endpointHost });
+	}
+	get authEnabled() {
+		return this.#auth?.enabled() ?? false;
+	}
+	async resolveOrgId(resourceId) {
+		try {
+			return (await this.projects.getById({ id: resourceId }))?.orgId ?? null;
+		} catch {
+			return null;
+		}
+	}
+	async loadConnection(orgId) {
+		const workspace = (await this.#listWorkspaces())[0];
+		if (!workspace) return null;
+		const now = /* @__PURE__ */ new Date();
+		return {
+			id: `platform-linear:${orgId}`,
+			orgId,
+			userId: null,
+			accessToken: PLATFORM_MANAGED_CONNECTION_TOKEN,
+			scope: "read,comments:create",
+			refreshToken: null,
+			expiresAt: null,
+			workspaceName: workspace.linearWorkspaceName,
+			workspaceUrlKey: workspace.urlKey,
+			createdAt: now,
+			updatedAt: now
+		};
+	}
+	async getFreshAccessToken(_connection) {
+		return PLATFORM_MANAGED_CONNECTION_TOKEN;
+	}
+	/**
+	* Background-dispatch context: platform-managed connection token when the
+	* org has a connected workspace. Linear work items store the issue UUID
+	* directly as `externalId`.
+	*/
+	async #resolveIntakeDispatch({ orgId, externalSource }) {
+		if (externalSource.type !== "issue") return null;
+		if (!await this.loadConnection(orgId)) return null;
+		return {
+			connection: {
+				type: "oauth",
+				accessToken: PLATFORM_MANAGED_CONNECTION_TOKEN
+			},
+			issueId: externalSource.externalId
+		};
+	}
+	canPostComments(connection) {
+		return (connection.scope ?? "").split(/[\s,]+/).filter(Boolean).some((scope) => scope === "comments:create" || scope === "write" || scope === "admin");
+	}
+	async checkConnection(orgId) {
+		const connection = await this.loadConnection(orgId);
+		return {
+			connected: connection !== null,
+			canComment: connection !== null && this.canPostComments(connection),
+			checkedAt: Date.now()
+		};
+	}
+	workers(ctx) {
+		const pollingEnabled = process.env.MASTRACODE_PLATFORM_LINEAR_POLLING_ENABLED?.trim().toLowerCase() !== "false";
+		const reconcileEnabled = linearIssueReconciliationEnabled();
+		if (!pollingEnabled && !reconcileEnabled) return [];
+		const ingest = attachLinearRules(this, ctx);
+		const reconcile = reconcileEnabled ? attachLinearIssueReconciler(this, ctx) : void 0;
+		const workItems = ctx.runtime?.workItems;
+		if (!workItems) return [];
+		if (!ingest && !reconcile) return [];
+		const pollIntervalMs = optionalPositiveIntegerEnv("MASTRACODE_PLATFORM_LINEAR_POLLING_INTERVAL_MS");
+		const reconcileIntervalMs = linearIssueReconciliationInterval();
+		return [new PlatformLinearEventWorker({
+			client: this.#client,
+			linear: { listWorkspaces: () => this.listWorkspaces() },
+			storage: ctx.storage.generic,
+			projects: ctx.storage.projects,
+			workItems,
+			...ingest ? { ingestFactoryIssue: ingest } : {},
+			...reconcile ? { reconcileFactoryState: reconcile } : {},
+			pollEventsEnabled: pollingEnabled,
+			...pollIntervalMs !== void 0 ? { intervalMs: pollIntervalMs } : {},
+			...reconcileIntervalMs !== void 0 ? { reconcileIntervalMs } : {}
+		})];
+	}
+	routes(ctx) {
+		return [this.#connectRoute(ctx), ...buildLinearRoutes({
+			auth: ctx.auth,
+			linear: this,
+			stateSigner: ctx.stateSigner,
+			baseUrl: ctx.baseUrl,
+			intake: ctx.storage.intake,
+			projects: ctx.storage.projects,
+			ingestFactoryIssues: attachLinearRules(this, ctx),
+			workItems: ctx.runtime?.workItems,
+			boards: ctx.runtime?.boards
+		}).filter((route) => !route.path.startsWith("/auth/linear/"))];
+	}
+	#connectRoute(ctx) {
+		return registerApiRoute("/auth/linear/connect", {
+			method: "GET",
+			requiresAuth: false,
+			handler: async (c) => {
+				await ctx.auth.ensureUser(loose(c));
+				const tenant = ctx.auth.tenant(loose(c));
+				if (!tenant?.orgId) return c.json({ error: "unauthorized" }, 401);
+				const returnTo = c.req.query("return_to") || "/";
+				const originator = routeBaseUrl(ctx, c.req.url);
+				logPlatformInfo("Starting Platform Linear connect flow", {
+					orgId: tenant.orgId,
+					returnTo,
+					originator
+				});
+				const query = new URLSearchParams({
+					return_to: returnTo,
+					originator
+				});
+				const location = await this.#client.requestRedirect("GET", `${API_PREFIX}/authorize?${query}`);
+				return c.redirect(location);
+			}
+		});
+	}
+	async agentTools({ requestContext }) {
+		return buildLinearAgentTools({
+			requestContext,
+			linear: this
+		});
+	}
+	diagnostics() {
+		return {
+			mode: "platform",
+			endpointHost: this.#endpointHost
+		};
+	}
+	async listProjects() {
+		return (await this.#listProjectSources()).map(({ workspace, project }) => ({
+			...project,
+			id: encodeSourceId(workspace.linearWorkspaceId, project.id),
+			workspaceId: workspace.linearWorkspaceId
+		}));
+	}
+	async listTeams(_accessToken) {
+		return (await this.#listTeamSources()).map(({ workspace, team }) => ({
+			...team,
+			workspaceId: workspace.linearWorkspaceId,
+			sourceId: encodeTeamSourceId(workspace.linearWorkspaceId, team.id)
+		}));
+	}
+	async fetchIssueDetail(_accessToken, idOrIdentifier, sourceIds, routedSourceIds) {
+		const located = await this.#findIssue(void 0, idOrIdentifier, sourceIds, routedSourceIds);
+		if (!located) return null;
+		const comments = await this.#loadComments(located.workspaceId, located.issue.id, located.issue.comments);
+		const issue = located.issue;
+		return {
+			id: issue.id,
+			projectId: issue.project?.id ?? null,
+			workspaceId: located.workspaceId,
+			teamId: issue.team.id,
+			identifier: issue.identifier,
+			title: issue.title,
+			description: issue.description?.trim() ? issue.description : null,
+			url: issue.url,
+			state: issue.state.name,
+			stateType: issue.state.type,
+			priorityLabel: issue.priorityLabel,
+			assignee: issue.assignee?.displayName ?? issue.assignee?.name ?? null,
+			creator: issue.creator?.displayName ?? issue.creator?.name ?? null,
+			team: issue.team.key,
+			labels: issue.labels.map((label) => label.name),
+			createdAt: issue.createdAt,
+			updatedAt: issue.updatedAt,
+			comments: comments.map((comment) => ({
+				author: comment.user?.displayName ?? comment.user?.name ?? null,
+				body: comment.body,
+				createdAt: comment.createdAt
+			}))
+		};
+	}
+	sourceMatchesIssue(sourceId, issue) {
+		const source = parseSourceId(sourceId);
+		if (issue.workspaceId !== source.workspaceId) return false;
+		return source.kind === "team" ? issue.teamId === source.teamId : issue.projectId === source.projectId;
+	}
+	async #listProjectSources(workspaceIds) {
+		const workspaces = await this.#listWorkspaces();
+		const scopedWorkspaces = workspaceIds ? workspaces.filter((workspace) => workspaceIds.has(workspace.linearWorkspaceId)) : workspaces;
+		return (await Promise.all(scopedWorkspaces.map(async (workspace) => {
+			const projects = [];
+			let after;
+			for (let page = 0; page < MAX_REFERENCE_PAGES; page += 1) {
+				const query = new URLSearchParams({ first: "200" });
+				if (after) query.set("after", after);
+				const result = await this.#client.request("GET", `${API_PREFIX}/workspaces/${encodeURIComponent(workspace.linearWorkspaceId)}/projects?${query}`);
+				projects.push(...result.projects);
+				if (!result.pageInfo.hasNextPage || !result.pageInfo.endCursor) break;
+				if (result.pageInfo.endCursor === after) throw invalidLinearCursor();
+				after = result.pageInfo.endCursor;
+			}
+			return projects.map((project) => ({
+				workspace,
+				project
+			}));
+		}))).flat();
+	}
+	async #listTeamSources(workspaceIds) {
+		const workspaces = await this.#listWorkspaces();
+		const scopedWorkspaces = workspaceIds ? workspaces.filter((workspace) => workspaceIds.has(workspace.linearWorkspaceId)) : workspaces;
+		return (await Promise.all(scopedWorkspaces.map(async (workspace) => {
+			const teams = [];
+			let after;
+			for (let page = 0; page < MAX_REFERENCE_PAGES; page += 1) {
+				const query = new URLSearchParams({ first: "200" });
+				if (after) query.set("after", after);
+				const result = await this.#client.request("GET", `${API_PREFIX}/workspaces/${encodeURIComponent(workspace.linearWorkspaceId)}/teams?${query}`);
+				teams.push(...result.teams);
+				if (!result.pageInfo.hasNextPage || !result.pageInfo.endCursor) break;
+				if (result.pageInfo.endCursor === after) throw invalidLinearCursor();
+				after = result.pageInfo.endCursor;
+			}
+			return teams.map((team) => ({
+				workspace,
+				team
+			}));
+		}))).flat();
+	}
+	async listWorkspaces() {
+		return this.#listWorkspaces();
+	}
+	async #listWorkspaces() {
+		return (await this.#client.request("GET", `${API_PREFIX}/workspaces`)).workspaces.filter((workspace) => workspace.connected);
+	}
+	async #listIssues(sourceIds, cursor, labels, attributionSourceIds = sourceIds) {
+		if (sourceIds.length === 0) return {
+			issues: [],
+			nextCursor: null
+		};
+		const parsedSources = sourceIds.map((sourceId) => parseSourceId(sourceId));
+		const projectWorkspaceIds = new Set(parsedSources.flatMap((source) => source.kind === "project" ? [source.workspaceId] : []));
+		const teamWorkspaceIds = new Set(parsedSources.flatMap((source) => source.kind === "team" ? [source.workspaceId] : []));
+		const [projectSources, teamSources] = await Promise.all([projectWorkspaceIds.size > 0 ? this.#listProjectSources(projectWorkspaceIds) : Promise.resolve([]), teamWorkspaceIds.size > 0 ? this.#listTeamSources(teamWorkspaceIds) : Promise.resolve([])]);
+		const projectMap = new Map(projectSources.map((source) => [encodeSourceId(source.workspace.linearWorkspaceId, source.project.id), source]));
+		const teamMap = new Map(teamSources.map((source) => [encodeTeamSourceId(source.workspace.linearWorkspaceId, source.team.id), source]));
+		const descriptors = [];
+		const selectedProjectIdsByWorkspace = /* @__PURE__ */ new Map();
+		for (const attributionSourceId of attributionSourceIds) {
+			const source = parseSourceId(attributionSourceId);
+			if (source.kind !== "project") continue;
+			const selectedProjectIds = selectedProjectIdsByWorkspace.get(source.workspaceId) ?? /* @__PURE__ */ new Set();
+			selectedProjectIds.add(source.projectId);
+			selectedProjectIdsByWorkspace.set(source.workspaceId, selectedProjectIds);
+		}
+		for (const sourceId of sourceIds) {
+			const projectSource = projectMap.get(sourceId);
+			if (projectSource) {
+				const query = new URLSearchParams({
+					first: String(PAGE_SIZE),
+					projectIds: projectSource.project.id,
+					stateType: "triage,backlog,unstarted,started",
+					orderBy: "updatedAt"
+				});
+				const workspaceId = projectSource.workspace.linearWorkspaceId;
+				const selectedProjectIds = selectedProjectIdsByWorkspace.get(workspaceId) ?? /* @__PURE__ */ new Set();
+				selectedProjectIds.add(projectSource.project.id);
+				selectedProjectIdsByWorkspace.set(workspaceId, selectedProjectIds);
+				descriptors.push({
+					kind: "project",
+					sourceId,
+					workspace: projectSource.workspace,
+					query
+				});
+				continue;
+			}
+			const teamSource = teamMap.get(sourceId);
+			if (teamSource) {
+				const query = new URLSearchParams({
+					first: String(PAGE_SIZE),
+					teamId: teamSource.team.id,
+					stateType: "triage,backlog,unstarted,started",
+					orderBy: "updatedAt"
+				});
+				descriptors.push({
+					kind: "team",
+					sourceId,
+					workspace: teamSource.workspace,
+					query
+				});
+			}
+		}
+		const cursors = await decodeCursor(cursor, sourceIds, attributionSourceIds);
+		const normalizedLabels = normalizeLabels(labels);
+		const nextState = {};
+		let hasNextPage = false;
+		return {
+			issues: dedupeIssuesBySource((await Promise.all(descriptors.map(async ({ kind, sourceId, workspace, query }) => {
+				if (cursors[sourceId] === null) {
+					nextState[sourceId] = null;
+					return [];
+				}
+				const after = cursors[sourceId];
+				if (after) query.set("after", after);
+				const result = await this.#client.request("GET", `${API_PREFIX}/workspaces/${encodeURIComponent(workspace.linearWorkspaceId)}/issues?${query}`);
+				const next = result.pageInfo.hasNextPage ? result.pageInfo.endCursor : null;
+				if (next !== null && next === after) throw invalidLinearCursor();
+				nextState[sourceId] = next;
+				hasNextPage ||= next !== null;
+				return result.issues.filter((issue) => normalizedLabels.length === 0 || issue.labels.some((label) => normalizedLabels.includes(label.name))).filter((issue) => kind === "project" || issue.project === null || !selectedProjectIdsByWorkspace.get(workspace.linearWorkspaceId)?.has(issue.project.id)).map((issue) => ({
+					issue,
+					sourceId,
+					workspace
+				}));
+			}))).flat(), sourceIds),
+			nextCursor: hasNextPage ? await encodeCursor(nextState, sourceIds, attributionSourceIds) : null
+		};
+	}
+	async #findIssue(sourceId, issueId, sourceIds, routedSourceIds) {
+		const scopedSources = (sourceIds ?? (sourceId ? [sourceId] : void 0))?.map((sourceKey) => ({
+			sourceKey,
+			source: parseSourceId(sourceKey)
+		}));
+		const routedSourceSet = routedSourceIds ? new Set(routedSourceIds) : void 0;
+		const workspaceIds = routedSourceIds ? [...new Set(routedSourceIds.map((sourceKey) => parseSourceId(sourceKey).workspaceId))] : scopedSources ? [...new Set(scopedSources.map(({ source }) => source.workspaceId))] : await this.#candidateWorkspaceIds(void 0);
+		for (const workspaceId of workspaceIds) try {
+			const issue = await this.#client.request("GET", `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/issues/${encodeURIComponent(issueId)}?include=comments`);
+			if (scopedSources) {
+				const matching = scopedSources.filter(({ source }) => source.workspaceId === workspaceId && (source.kind === "team" ? issue.team.id === source.teamId : issue.project?.id === source.projectId));
+				const winner = matching.find(({ source }) => source.kind === "project") ?? matching[0];
+				if (!winner || routedSourceSet && !routedSourceSet.has(winner.sourceKey)) continue;
+			}
+			return {
+				workspaceId,
+				issue
+			};
+		} catch (error) {
+			if (!isNotFound(error)) throw error;
+		}
+		return null;
+	}
+	async #resolveWorkspaceForIssue(sourceId, issueId) {
+		const workspaceIds = await this.#candidateWorkspaceIds(sourceId);
+		if (workspaceIds.length === 1) return workspaceIds[0];
+		for (const workspaceId of workspaceIds) try {
+			await this.#client.request("GET", `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/issues/${encodeURIComponent(issueId)}`);
+			return workspaceId;
+		} catch (error) {
+			if (!isNotFound(error)) throw error;
+		}
+		return null;
+	}
+	async #listWorkflowStates(workspaceId, teamId) {
+		const cacheKey = `${workspaceId}:${teamId}`;
+		const cached = this.#workflowStatesByTeam.get(cacheKey);
+		if (cached) return cached;
+		const result = await this.#client.request("GET", `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/workflow-states?teamId=${encodeURIComponent(teamId)}&first=100`);
+		this.#workflowStatesByTeam.set(cacheKey, result.workflowStates);
+		return result.workflowStates;
+	}
+	async #candidateWorkspaceIds(sourceId) {
+		if (sourceId) return [parseSourceId(sourceId).workspaceId];
+		return (await this.#listWorkspaces()).map((workspace) => workspace.linearWorkspaceId);
+	}
+	async #loadComments(workspaceId, issueId, embedded) {
+		const comments = [...embedded?.nodes ?? []];
+		let pageInfo = embedded?.pageInfo;
+		let page = 0;
+		while (pageInfo?.hasNextPage && pageInfo.endCursor && page < MAX_COMMENT_PAGES) {
+			const result = await this.#client.request("GET", `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/issues/${encodeURIComponent(issueId)}/comments?first=200&after=${encodeURIComponent(pageInfo.endCursor)}`);
+			comments.push(...result.comments);
+			if (result.pageInfo.hasNextPage && result.pageInfo.endCursor === pageInfo.endCursor) throw invalidLinearCursor();
+			pageInfo = result.pageInfo;
+			page += 1;
+		}
+		return comments;
+	}
+};
+function parseIssue(issue, workspaceId) {
+	return {
+		id: issue.id,
+		identifier: issue.identifier,
+		title: issue.title,
+		url: issue.url,
+		author: issue.creator?.displayName ?? issue.creator?.name ?? null,
+		state: issue.state.name,
+		stateType: issue.state.type,
+		priority: issue.priorityLabel,
+		assignee: issue.assignee?.displayName ?? issue.assignee?.name ?? null,
+		source: issue.team.key,
+		projectId: issue.project ? encodeSourceId(workspaceId, issue.project.id) : null,
+		labels: issue.labels.map((label) => label.name),
+		commentCount: null,
+		createdAt: issue.createdAt,
+		updatedAt: issue.updatedAt
+	};
+}
+function parseIssueDetail(issue, comments, workspaceId) {
+	return {
+		...parseIssue(issue, workspaceId),
+		commentCount: comments.length,
+		description: issue.description?.trim() ? issue.description : null,
+		comments: comments.map((comment) => ({
+			author: comment.user?.displayName ?? comment.user?.name ?? null,
+			body: comment.body,
+			createdAt: comment.createdAt
+		}))
+	};
+}
+/**
+* Deduplicate issues that surfaced from more than one selected source (a team
+* source and one of its projects both select the same issue). Keeps one entry
+* per Linear issue UUID.
+*
+* Tie-breaker — MOST-SPECIFIC-WINS: a project source beats a team source, so an
+* issue that belongs to a selected project is attributed to that project's
+* source (and therefore routes to the project's board). The team source covers
+* only the remainder — projectless issues and issues in projects that were not
+* separately selected. `selectionOrder` breaks a same-kind tie deterministically
+* by the order the sources were selected.
+*
+* This function is the single precedence point; change the comparison here to
+* change the routing policy.
+*/
+function dedupeIssuesBySource(entries, selectionOrder) {
+	const rank = new Map(selectionOrder.map((id, index) => [id, index]));
+	const specificity = (sourceId) => parseSourceId(sourceId).kind === "project" ? 0 : 1;
+	const winners = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const existing = winners.get(entry.issue.id);
+		if (!existing) {
+			winners.set(entry.issue.id, entry);
+			continue;
+		}
+		const bySpecificity = specificity(entry.sourceId) - specificity(existing.sourceId);
+		if (bySpecificity < 0 || bySpecificity === 0 && (rank.get(entry.sourceId) ?? Number.MAX_SAFE_INTEGER) < (rank.get(existing.sourceId) ?? Number.MAX_SAFE_INTEGER)) winners.set(entry.issue.id, entry);
+	}
+	const seen = /* @__PURE__ */ new Set();
+	const ordered = [];
+	for (const entry of entries) {
+		if (seen.has(entry.issue.id)) continue;
+		seen.add(entry.issue.id);
+		ordered.push(winners.get(entry.issue.id));
+	}
+	return ordered;
+}
+function encodeSourceId(workspaceId, projectId) {
+	return `linear-project:${Buffer.from(JSON.stringify({
+		workspaceId,
+		projectId
+	})).toString("base64url")}`;
+}
+function decodeSourceId(sourceId) {
+	if (!sourceId.startsWith("linear-project:")) throw new Error("Linear project source id is invalid.");
+	try {
+		const parsed = JSON.parse(Buffer.from(sourceId.slice(15), "base64url").toString("utf8"));
+		if (typeof parsed.workspaceId !== "string" || !parsed.workspaceId) throw new Error();
+		if (typeof parsed.projectId !== "string" || !parsed.projectId) throw new Error();
+		return {
+			workspaceId: parsed.workspaceId,
+			projectId: parsed.projectId
+		};
+	} catch {
+		throw new Error("Linear project source id is invalid.");
+	}
+}
+const TEAM_SOURCE_PREFIX = "linear-team:";
+function encodeTeamSourceId(workspaceId, teamId) {
+	return `${TEAM_SOURCE_PREFIX}${Buffer.from(JSON.stringify({
+		workspaceId,
+		teamId
+	})).toString("base64url")}`;
+}
+function decodeTeamSourceId(sourceId) {
+	if (!sourceId.startsWith(TEAM_SOURCE_PREFIX)) throw new Error("Linear team source id is invalid.");
+	try {
+		const parsed = JSON.parse(Buffer.from(sourceId.slice(12), "base64url").toString("utf8"));
+		if (typeof parsed.workspaceId !== "string" || !parsed.workspaceId) throw new Error();
+		if (typeof parsed.teamId !== "string" || !parsed.teamId) throw new Error();
+		return {
+			workspaceId: parsed.workspaceId,
+			teamId: parsed.teamId
+		};
+	} catch {
+		throw new Error("Linear team source id is invalid.");
+	}
+}
+/** Discriminate any Linear source id by its prefix and decode it. */
+function parseSourceId(sourceId) {
+	if (sourceId.startsWith(TEAM_SOURCE_PREFIX)) return {
+		kind: "team",
+		...decodeTeamSourceId(sourceId)
+	};
+	return {
+		kind: "project",
+		...decodeSourceId(sourceId)
+	};
+}
+function normalizeLabels(labels) {
+	return [...new Set((labels ?? []).map((label) => label.trim()).filter(Boolean))];
+}
+function canonicalSourceIds(sourceIds) {
+	return [...new Set(sourceIds)].sort();
+}
+async function linearSourceSetFingerprint(sourceIds, attributionSourceIds) {
+	const scope = {
+		sourceIds: canonicalSourceIds(sourceIds),
+		attributionSourceIds: canonicalSourceIds(attributionSourceIds)
+	};
+	const bytes = new TextEncoder().encode(JSON.stringify(scope));
+	return Buffer.from(await globalThis.crypto.subtle.digest("SHA-256", bytes)).toString("base64url");
+}
+function invalidLinearCursor() {
+	return Object.assign(/* @__PURE__ */ new Error("Linear cursor is invalid or stale."), { code: "invalid_cursor" });
+}
+async function decodeCursor(cursor, sourceIds, attributionSourceIds) {
+	if (!cursor) return {};
+	try {
+		const parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+		const canonical = canonicalSourceIds(sourceIds);
+		if (parsed.v !== 1 || parsed.sourceSet !== await linearSourceSetFingerprint(sourceIds, attributionSourceIds) || !Array.isArray(parsed.cursors) || parsed.cursors.length !== canonical.length || !parsed.cursors.every((value) => value === null || typeof value === "string")) throw invalidLinearCursor();
+		return Object.fromEntries(canonical.map((sourceId, index) => [sourceId, parsed.cursors[index]]));
+	} catch {
+		throw invalidLinearCursor();
+	}
+}
+async function encodeCursor(state, sourceIds, attributionSourceIds) {
+	const canonical = canonicalSourceIds(sourceIds);
+	const cursor = {
+		v: 1,
+		sourceSet: await linearSourceSetFingerprint(sourceIds, attributionSourceIds),
+		cursors: canonical.map((sourceId) => state[sourceId] ?? null)
+	};
+	return Buffer.from(JSON.stringify(cursor)).toString("base64url");
+}
+function requireLinearConnection(connection) {
+	if (connection.type !== "oauth") throw new Error("Linear capabilities require an OAuth connection.");
+}
+function isNotFound(error) {
+	return error instanceof PlatformApiError && error.status === 404;
+}
+function optionalPositiveIntegerEnv(name) {
+	const value = process.env[name]?.trim();
+	if (!value) return void 0;
+	const parsed = Number(value);
+	if (!Number.isSafeInteger(parsed) || parsed <= 0) throw new Error(`${name} must be a positive integer.`);
+	return parsed;
+}
+//#endregion
+export { PlatformLinearIntegration, decodeTeamSourceId, encodeSourceId, encodeTeamSourceId, parseSourceId };
+
+//# sourceMappingURL=integration.js.map