@mastra/factory 0.15.0 → 0.16.0-alpha.10

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

@@ -7,6 +7,7 @@ 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";
+import { createHash } from "crypto";
 //#region src/integrations/platform/linear/integration.ts
 const API_PREFIX = "/v1/server/linear";
 const PAGE_SIZE = 30;
@@ -34,7 +35,8 @@ var PlatformLinearIntegration = class {
 	intake = {
 		resolveIntakeDispatch: (input) => this.#resolveIntakeDispatch(input),
 		listSources: async () => {
-			return (await this.#listProjectSources()).map(({ workspace, project }) => ({
+			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",
@@ -46,17 +48,29 @@ var PlatformLinearIntegration = class {
 					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, cursor }) => {
-			const result = await this.#listIssues(sourceIds, cursor);
+		listItems: async ({ sourceIds, attributionSourceIds, cursor }) => {
+			const result = await this.#listIssues(sourceIds, cursor, void 0, attributionSourceIds);
 			return {
-				items: result.issues.map(({ issue, source }) => ({
+				items: result.issues.map(({ issue, sourceId, workspace }) => ({
 					source: {
 						type: "issue",
 						externalId: issue.id,
 						url: issue.url
 					},
-					sourceId: encodeSourceId(source.workspace.linearWorkspaceId, source.project.id),
+					sourceId,
 					title: issue.title,
 					status: issue.state.name,
 					labels: issue.labels.map((label) => label.name),
@@ -65,10 +79,9 @@ var PlatformLinearIntegration = class {
 					updatedAt: issue.updatedAt,
 					metadata: {
 						identifier: issue.identifier,
-						workspaceId: source.workspace.linearWorkspaceId,
-						workspaceName: source.workspace.linearWorkspaceName,
-						projectId: source.project.id,
-						projectName: source.project.name,
+						workspaceId: workspace.linearWorkspaceId,
+						workspaceName: workspace.linearWorkspaceName,
+						projectId: issue.project?.id ?? null,
 						team: issue.team.key,
 						priority: issue.priorityLabel
 					}
@@ -76,13 +89,13 @@ var PlatformLinearIntegration = class {
 				nextCursor: result.nextCursor
 			};
 		},
-		listIssues: async ({ connection, sourceIds, labels, cursor }) => {
+		listIssues: async ({ connection, sourceIds, attributionSourceIds, labels, cursor }) => {
 			requireLinearConnection(connection);
-			const result = await this.#listIssues(sourceIds, cursor, labels);
+			const result = await this.#listIssues(sourceIds, cursor, labels, attributionSourceIds);
 			return {
-				issues: result.issues.map(({ issue, source }) => ({
+				issues: result.issues.map(({ issue, sourceId }) => ({
 					...parseIssue(issue),
-					sourceId: encodeSourceId(source.workspace.linearWorkspaceId, source.project.id)
+					sourceId
 				})),
 				nextCursor: result.nextCursor
 			};
@@ -285,7 +298,9 @@ var PlatformLinearIntegration = class {
 			baseUrl: ctx.baseUrl,
 			intake: ctx.storage.intake,
 			projects: ctx.storage.projects,
-			ingestFactoryIssues: attachLinearRules(this, ctx)
+			ingestFactoryIssues: attachLinearRules(this, ctx),
+			workItems: ctx.runtime?.workItems,
+			boards: ctx.runtime?.boards
 		}).filter((route) => !route.path.startsWith("/auth/linear/"))];
 	}
 	#connectRoute(ctx) {
@@ -331,9 +346,52 @@ var PlatformLinearIntegration = class {
 			workspaceId: workspace.linearWorkspaceId
 		}));
 	}
-	async #listProjectSources() {
+	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();
-		return (await Promise.all(workspaces.map(async (workspace) => {
+		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) {
@@ -342,6 +400,7 @@ var PlatformLinearIntegration = class {
 				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) => ({
@@ -350,57 +409,133 @@ var PlatformLinearIntegration = class {
 			}));
 		}))).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) {
+	async #listIssues(sourceIds, cursor, labels, attributionSourceIds = sourceIds) {
 		if (sourceIds.length === 0) return {
 			issues: [],
 			nextCursor: null
 		};
-		const sources = await this.#listProjectSources();
-		const sourceMap = new Map(sources.map((source) => [encodeSourceId(source.workspace.linearWorkspaceId, source.project.id), source]));
-		const selected = sourceIds.map((sourceId) => sourceMap.get(sourceId)).filter((source) => !!source);
-		const cursors = decodeCursor(cursor, sourceIds);
+		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 = decodeCursor(cursor, sourceIds, attributionSourceIds);
 		const normalizedLabels = normalizeLabels(labels);
 		const nextState = {};
 		let hasNextPage = false;
 		return {
-			issues: (await Promise.all(selected.map(async (source) => {
-				const sourceId = encodeSourceId(source.workspace.linearWorkspaceId, source.project.id);
+			issues: dedupeIssuesBySource((await Promise.all(descriptors.map(async ({ kind, sourceId, workspace, query }) => {
 				if (cursors[sourceId] === null) {
 					nextState[sourceId] = null;
 					return [];
 				}
-				const query = new URLSearchParams({
-					first: String(PAGE_SIZE),
-					projectIds: source.project.id,
-					stateType: "triage,backlog,unstarted,started",
-					orderBy: "updatedAt"
-				});
 				const after = cursors[sourceId];
 				if (after) query.set("after", after);
-				const result = await this.#client.request("GET", `${API_PREFIX}/workspaces/${encodeURIComponent(source.workspace.linearWorkspaceId)}/issues?${query}`);
+				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))).map((issue) => ({
+				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,
-					source
+					sourceId,
+					workspace
 				}));
-			}))).flat(),
-			nextCursor: hasNextPage ? encodeCursor(nextState, sourceIds) : null
+			}))).flat(), sourceIds),
+			nextCursor: hasNextPage ? encodeCursor(nextState, sourceIds, attributionSourceIds) : null
 		};
 	}
-	async #findIssue(sourceId, issueId) {
-		const workspaceIds = await this.#candidateWorkspaceIds(sourceId);
+	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: await this.#client.request("GET", `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/issues/${encodeURIComponent(issueId)}?include=comments`)
+				issue
 			};
 		} catch (error) {
 			if (!isNotFound(error)) throw error;
@@ -427,7 +562,7 @@ var PlatformLinearIntegration = class {
 		return result.workflowStates;
 	}
 	async #candidateWorkspaceIds(sourceId) {
-		if (sourceId) return [decodeSourceId(sourceId).workspaceId];
+		if (sourceId) return [parseSourceId(sourceId).workspaceId];
 		return (await this.#listWorkspaces()).map((workspace) => workspace.linearWorkspaceId);
 	}
 	async #loadComments(workspaceId, issueId, embedded) {
@@ -437,6 +572,7 @@ var PlatformLinearIntegration = class {
 		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;
 		}
@@ -473,6 +609,43 @@ function parseIssueDetail(issue, comments) {
 		}))
 	};
 }
+/**
+* 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,
@@ -493,23 +666,73 @@ function decodeSourceId(sourceId) {
 		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 decodeCursor(cursor, sourceIds) {
+function canonicalSourceIds(sourceIds) {
+	return [...new Set(sourceIds)].sort();
+}
+function linearSourceSetFingerprint(sourceIds, attributionSourceIds) {
+	const scope = {
+		sourceIds: canonicalSourceIds(sourceIds),
+		attributionSourceIds: canonicalSourceIds(attributionSourceIds)
+	};
+	return createHash("sha256").update(JSON.stringify(scope)).digest("base64url");
+}
+function invalidLinearCursor() {
+	return Object.assign(/* @__PURE__ */ new Error("Linear cursor is invalid or stale."), { code: "invalid_cursor" });
+}
+function decodeCursor(cursor, sourceIds, attributionSourceIds) {
 	if (!cursor) return {};
-	if (sourceIds.length === 1) return { [sourceIds[0]]: cursor };
 	try {
-		const parsed = JSON.parse(cursor);
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error();
-		return parsed;
+		const parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+		const canonical = canonicalSourceIds(sourceIds);
+		if (parsed.v !== 1 || parsed.sourceSet !== 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 new Error("Linear cursor is invalid.");
+		throw invalidLinearCursor();
 	}
 }
-function encodeCursor(state, sourceIds) {
-	if (sourceIds.length === 1) return state[sourceIds[0]];
-	return JSON.stringify(state);
+function encodeCursor(state, sourceIds, attributionSourceIds) {
+	const canonical = canonicalSourceIds(sourceIds);
+	const cursor = {
+		v: 1,
+		sourceSet: 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.");
@@ -525,6 +748,6 @@ function optionalPositiveIntegerEnv(name) {
 	return parsed;
 }
 //#endregion
-export { PlatformLinearIntegration };
+export { PlatformLinearIntegration, decodeTeamSourceId, encodeSourceId, encodeTeamSourceId, parseSourceId };
 
 //# sourceMappingURL=integration.js.map