@mastra/factory 0.0.0-aggregate-trace-20261015182851

package/dist/routes/intake.js

@@ -0,0 +1,627 @@
+import { cardLabels, moveCardToBoard } from "../boards/relocate.js";
+import { normalizeIntakeLabel, resolveIntakeLabelRoute } from "../storage/domains/intake/base.js";
+import { Route } from "./route.js";
+import { registerApiRoute } from "@mastra/core/server";
+import { z } from "zod";
+//#region src/routes/intake.ts
+/** Upper bound on source pages read while relocating cards, so a huge source cannot stall the request. */
+const REBIND_MAX_PAGES = 20;
+/**
+* One deadline for the whole rebind read, not one per page: the binding is already saved when we
+* get here, so the caller is only waiting on relocation and a slow provider must not hold the
+* response for pages × timeout.
+*/
+const REBIND_READ_BUDGET_MS = 3e4;
+/**
+* Keys under which an intake item may be persisted as a work item. Providers key items by their
+* own id, while materialization uses the human identifier (`linear:MAS-44`), so both are accepted.
+*/
+function intakeItemSourceKeys(integrationId, item) {
+	const identifier = item.metadata?.identifier;
+	return typeof identifier === "string" && identifier.length > 0 ? [item.source.externalId, `${integrationId}:${identifier}`] : [item.source.externalId];
+}
+/**
+* Move the cards that came from a rebound source onto its new board's initial phase. Terminal cards
+* stay put (they are history that belongs where it finished), as do cards with a session attached to
+* a current stage (a run owns them). Everything else moves, including cards parked in a working
+* phase that never started a run — auto-ingested issues sit in Work › Triage that way.
+*/
+async function relocateSourceCards({ workItems, integration, boardRegistry, orgId, userId, factoryProjectId, sourceId, targetBoard, attributionSourceIds }) {
+	if (!boardRegistry.has(targetBoard)) return {
+		moved: 0,
+		skipped: 0
+	};
+	const sourceKeys = /* @__PURE__ */ new Set();
+	let cursor;
+	const deadline = Date.now() + REBIND_READ_BUDGET_MS;
+	for (let page = 0; page < REBIND_MAX_PAGES; page += 1) {
+		const result = await withTimeout(integration.id, () => integration.intake.listItems({
+			orgId,
+			userId,
+			sourceIds: [sourceId],
+			attributionSourceIds,
+			cursor
+		}), deadline - Date.now());
+		for (const item of result.items) {
+			if (item.sourceId !== sourceId) continue;
+			for (const key of intakeItemSourceKeys(integration.id, item)) sourceKeys.add(key);
+		}
+		if (!result.nextCursor) break;
+		cursor = result.nextCursor;
+	}
+	if (sourceKeys.size === 0) return {
+		moved: 0,
+		skipped: 0
+	};
+	let moved = 0;
+	let skipped = 0;
+	const items = await workItems.list({
+		orgId,
+		factoryProjectId
+	});
+	for (const item of items) {
+		const source = item.externalSource;
+		if (!source || source.integrationId !== integration.id || !sourceKeys.has(source.externalId)) continue;
+		const outcome = await moveCardToBoard({
+			workItems,
+			boardRegistry,
+			userId,
+			item,
+			targetBoard
+		});
+		if (outcome === "moved") moved += 1;
+		else if (outcome === "skipped") skipped += 1;
+	}
+	return {
+		moved,
+		skipped
+	};
+}
+/**
+* After a label route changes, every issue card in the project that carries `label` is re-routed
+* under the project's current routes: to the board its labels now select, or — when none of them is
+* routed any more — to its GitHub repository binding's board, falling back to Work.
+*/
+async function relocateLabeledCards({ workItems, boardRegistry, orgId, userId, factoryProjectId, integrationId, label, routes, intake, githubRepositories }) {
+	const changed = normalizeIntakeLabel(label);
+	const repositoryBoards = integrationId === "github" ? await githubRepositoryBoards({
+		intake,
+		githubRepositories,
+		boardRegistry,
+		orgId,
+		factoryProjectId
+	}) : [];
+	let moved = 0;
+	let skipped = 0;
+	for (const item of await workItems.list({
+		orgId,
+		factoryProjectId
+	})) {
+		const source = item.externalSource;
+		if (!source || source.integrationId !== integrationId || source.type !== "issue") continue;
+		const labels = cardLabels(item);
+		if (!labels.some((candidate) => normalizeIntakeLabel(candidate) === changed)) continue;
+		const outcome = await moveCardToBoard({
+			workItems,
+			boardRegistry,
+			userId,
+			item,
+			targetBoard: resolveIntakeLabelRoute(routes, labels)?.board ?? repositoryBoards.find((candidate) => cardInRepository(item, candidate))?.board ?? "work"
+		});
+		if (outcome === "moved") moved += 1;
+		else if (outcome === "skipped") skipped += 1;
+	}
+	return {
+		moved,
+		skipped
+	};
+}
+/**
+* The project's GitHub repository bindings that name an installed board. A binding's source id is
+* the internal repository id or the repository slug, so ids are resolved to the slug and external id
+* a card carries.
+*/
+async function githubRepositoryBoards({ intake, githubRepositories, boardRegistry, orgId, factoryProjectId }) {
+	const boards = [];
+	for (const binding of await intake.listBindings({
+		orgId,
+		integrationId: "github"
+	})) {
+		if (binding.factoryProjectId !== factoryProjectId || !binding.board || !boardRegistry.has(binding.board)) continue;
+		const repository = await githubRepositories?.get({
+			orgId,
+			id: binding.sourceId
+		});
+		boards.push(repository ? {
+			board: binding.board,
+			slug: repository.slug.toLowerCase(),
+			externalId: repository.externalId
+		} : {
+			board: binding.board,
+			slug: binding.sourceId.toLowerCase()
+		});
+	}
+	return boards;
+}
+function cardInRepository(item, repository) {
+	const repositoryId = item.metadata?.githubRepositoryId;
+	if (repository.externalId !== void 0 && repositoryId !== void 0 && String(repositoryId) === repository.externalId) return true;
+	return /^https?:\/\/[^/]+\/(.+)\/(?:issues|pull)\/\d+(?:[/?#]|$)/.exec(item.externalSource?.url ?? "")?.[1]?.toLowerCase() === repository.slug;
+}
+const PROVIDER_READ_TIMEOUT_MS = 15e3;
+/** The Intake contract takes no abort signal, so a slow read is abandoned, not cancelled. */
+function withTimeout(integrationId, read, timeoutMs = PROVIDER_READ_TIMEOUT_MS) {
+	return new Promise((resolve, reject) => {
+		const budget = Math.max(0, timeoutMs);
+		const timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`${integrationId} did not answer within ${Math.round(budget / 1e3)}s`)), budget);
+		read().then(resolve, reject).finally(() => clearTimeout(timer));
+	});
+}
+/**
+* Read every integration concurrently and isolate the ones that throw or hang, so a single
+* unreachable provider degrades to a per-source error instead of failing the listing.
+*/
+async function settleByIntegration(requests) {
+	const settled = await Promise.all(requests.map(async ({ integrationId, read }) => {
+		try {
+			return {
+				integrationId,
+				value: await withTimeout(integrationId, read)
+			};
+		} catch (error) {
+			console.error(`[factory] intake integration ${integrationId} is unavailable:`, error);
+			return {
+				integrationId,
+				message: error instanceof Error ? error.message : String(error)
+			};
+		}
+	}));
+	const pages = [];
+	const failures = [];
+	for (const entry of settled) if ("value" in entry) pages.push(entry);
+	else failures.push(entry);
+	return {
+		pages,
+		failures
+	};
+}
+const MAX_INTAKE_SOURCE_ID_LENGTH = 1024;
+/** Validate a binding request body, rejecting unknown shapes. */
+function parseIntakeBinding(body) {
+	if (typeof body !== "object" || body === null || Array.isArray(body)) return null;
+	const { integrationId, sourceId, factoryProjectId, board } = body;
+	const isId = (value) => typeof value === "string" && value.length > 0 && value.length <= 256;
+	const isSourceId = (value) => typeof value === "string" && value.length > 0 && value.length <= MAX_INTAKE_SOURCE_ID_LENGTH;
+	if (!isId(integrationId) || !isSourceId(sourceId)) return null;
+	if (factoryProjectId !== null && !isId(factoryProjectId)) return null;
+	if (board !== void 0 && board !== null && !isId(board)) return null;
+	return {
+		integrationId,
+		sourceId,
+		factoryProjectId,
+		board: board ?? null
+	};
+}
+const identifier = z.string().min(1).max(256);
+const labelRouteBodySchema = z.object({
+	factoryProjectId: identifier,
+	integrationId: identifier,
+	label: z.string().max(256).transform(normalizeIntakeLabel).refine((label) => label.length > 0, "label must not be blank"),
+	/** Installed board target; `null` removes the route so the label falls back to Work. */
+	board: identifier.nullish().transform((board) => board ?? null)
+});
+/** Validate a label-route request body, rejecting unknown shapes. */
+function parseIntakeLabelRoute(body) {
+	const parsed = labelRouteBodySchema.safeParse(body);
+	return parsed.success ? parsed.data : null;
+}
+function loose(c) {
+	return c;
+}
+function sanitizeIdList(value) {
+	if (value === null) return null;
+	if (!Array.isArray(value) || value.length > 200) return void 0;
+	const ids = value.filter((item) => typeof item === "string" && item.length > 0 && item.length <= MAX_INTAKE_SOURCE_ID_LENGTH);
+	return ids.length === value.length && new Set(ids).size === ids.length ? ids : void 0;
+}
+function sanitizeLinearRepositoryMap(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const entries = Object.entries(value);
+	if (entries.length > 200) return void 0;
+	const mapping = Object.create(null);
+	for (const [projectId, slug] of entries) {
+		if (!projectId || projectId.length > MAX_INTAKE_SOURCE_ID_LENGTH || typeof slug !== "string" || !slug.trim() || slug.length > 512) return;
+		mapping[projectId] = slug;
+	}
+	return mapping;
+}
+/** Validate a request body into an intake config, rejecting unknown shapes. */
+function parseIntakeConfig(body) {
+	if (typeof body !== "object" || body === null || Array.isArray(body)) return null;
+	const entries = Object.entries(body);
+	if (entries.length > 50) return null;
+	const config = Object.create(null);
+	for (const [integrationId, value] of entries) {
+		if (!integrationId || integrationId.length > 128 || typeof value !== "object" || value === null || Array.isArray(value)) return null;
+		const selection = value;
+		if (typeof selection.enabled !== "boolean") return null;
+		const sourceIds = sanitizeIdList(selection.sourceIds ?? null);
+		if (sourceIds === void 0) return null;
+		const repositoryByLinearProject = integrationId === "linear" ? sanitizeLinearRepositoryMap(selection.repositoryByLinearProject) : void 0;
+		if (integrationId === "linear" && selection.repositoryByLinearProject !== void 0 && repositoryByLinearProject === void 0) return null;
+		config[integrationId] = {
+			enabled: selection.enabled,
+			sourceIds,
+			...repositoryByLinearProject ? { repositoryByLinearProject } : {}
+		};
+	}
+	return config;
+}
+function encodeCursor(cursors) {
+	return Object.keys(cursors).length > 0 ? Buffer.from(JSON.stringify(cursors)).toString("base64url") : null;
+}
+function decodeCursor(value) {
+	if (!value) return {};
+	try {
+		const parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+		const entries = Object.entries(parsed);
+		if (entries.some(([key, cursor]) => !key || typeof cursor !== "string")) return null;
+		return Object.fromEntries(entries);
+	} catch {
+		return null;
+	}
+}
+var IntakeRoutes = class extends Route {
+	async #resolveTenant(c) {
+		await this.deps.auth.ensureUser(c);
+		const tenant = this.deps.auth.tenant(c);
+		if (!tenant) return { response: c.json({ error: "unauthorized" }, 401) };
+		if (!tenant.orgId) return { response: c.json({
+			error: "organization_required",
+			message: "Intake configuration requires an organization."
+		}, 403) };
+		return {
+			orgId: tenant.orgId,
+			userId: tenant.userId
+		};
+	}
+	routes() {
+		const { audit, intake, projects, integrations = [], boardRegistry, workItems, githubRepositories } = this.deps;
+		const integrationIds = integrations.map((integration) => integration.id);
+		return [
+			registerApiRoute("/web/intake/config", {
+				method: "GET",
+				requiresAuth: false,
+				handler: async (c) => {
+					const tenant = await this.#resolveTenant(loose(c));
+					if ("response" in tenant) return tenant.response;
+					await intake.ensureReady();
+					const config = await intake.getConfig({
+						orgId: tenant.orgId,
+						integrationIds
+					});
+					return c.json({ config });
+				}
+			}),
+			registerApiRoute("/web/intake/config", {
+				method: "PUT",
+				requiresAuth: false,
+				handler: async (c) => {
+					const tenant = await this.#resolveTenant(loose(c));
+					if ("response" in tenant) return tenant.response;
+					let body;
+					try {
+						body = await c.req.json();
+					} catch {
+						return c.json({ error: "Invalid JSON body" }, 400);
+					}
+					const config = parseIntakeConfig(body);
+					if (!config) return c.json({ error: "invalid_config" }, 400);
+					const registeredConfig = Object.create(null);
+					for (const [integrationId, selection] of Object.entries(config)) {
+						if (integrationIds.includes(integrationId)) {
+							registeredConfig[integrationId] = selection;
+							continue;
+						}
+						if (selection.enabled || selection.sourceIds?.length) return c.json({ error: "invalid_config" }, 400);
+					}
+					await intake.ensureReady();
+					await intake.saveConfig({
+						orgId: tenant.orgId,
+						config: registeredConfig
+					});
+					await audit.emit({
+						context: loose(c),
+						input: {
+							action: "factory.intake.config_updated",
+							targets: [{
+								type: "intake_config",
+								id: tenant.orgId
+							}],
+							metadata: Object.fromEntries(Object.entries(registeredConfig).map(([integrationId, selection]) => [integrationId, {
+								enabled: selection.enabled,
+								sources: selection.sourceIds?.length ?? null
+							}]))
+						}
+					});
+					return c.json({ config: registeredConfig });
+				}
+			}),
+			registerApiRoute("/web/intake/bindings", {
+				method: "GET",
+				requiresAuth: false,
+				handler: async (c) => {
+					const tenant = await this.#resolveTenant(loose(c));
+					if ("response" in tenant) return tenant.response;
+					await intake.ensureReady();
+					return c.json({ bindings: await intake.listBindings({ orgId: tenant.orgId }) });
+				}
+			}),
+			registerApiRoute("/web/intake/bindings", {
+				method: "PUT",
+				requiresAuth: false,
+				handler: async (c) => {
+					const tenant = await this.#resolveTenant(loose(c));
+					if ("response" in tenant) return tenant.response;
+					let body;
+					try {
+						body = await c.req.json();
+					} catch {
+						return c.json({ error: "Invalid JSON body" }, 400);
+					}
+					const binding = parseIntakeBinding(body);
+					if (!binding || !integrationIds.includes(binding.integrationId)) return c.json({ error: "invalid_binding" }, 400);
+					if (binding.factoryProjectId && projects) {
+						if (!await projects.get({
+							orgId: tenant.orgId,
+							id: binding.factoryProjectId
+						})) return c.json({ error: "factory_project_not_found" }, 404);
+					}
+					if (binding.board !== null && !boardRegistry?.has(binding.board)) return c.json({
+						error: "invalid_board",
+						message: `Board '${binding.board}' is not installed.`
+					}, 422);
+					await intake.ensureReady();
+					let auditFactoryProjectId = binding.factoryProjectId;
+					let relocated = null;
+					if (binding.factoryProjectId === null) auditFactoryProjectId = (await intake.clearBinding({
+						orgId: tenant.orgId,
+						integrationId: binding.integrationId,
+						sourceId: binding.sourceId
+					}))?.factoryProjectId ?? null;
+					else {
+						const previousBinding = await intake.getBinding({
+							orgId: tenant.orgId,
+							integrationId: binding.integrationId,
+							sourceId: binding.sourceId
+						});
+						await intake.setBinding({
+							orgId: tenant.orgId,
+							userId: tenant.userId,
+							integrationId: binding.integrationId,
+							sourceId: binding.sourceId,
+							factoryProjectId: binding.factoryProjectId,
+							board: binding.board
+						});
+						const nextBoard = binding.board;
+						const integration = integrations.find((candidate) => candidate.id === binding.integrationId);
+						if (workItems && boardRegistry && integration && previousBinding?.factoryProjectId === binding.factoryProjectId && nextBoard !== null && previousBinding.board !== nextBoard) try {
+							const configuredSourceIds = (await intake.getConfig({
+								orgId: tenant.orgId,
+								integrationIds: [binding.integrationId]
+							}))[binding.integrationId]?.sourceIds ?? [];
+							const attributionSourceIds = configuredSourceIds.includes(binding.sourceId) ? configuredSourceIds : [...configuredSourceIds, binding.sourceId];
+							relocated = await relocateSourceCards({
+								workItems,
+								integration,
+								boardRegistry,
+								orgId: tenant.orgId,
+								userId: tenant.userId,
+								factoryProjectId: binding.factoryProjectId,
+								sourceId: binding.sourceId,
+								attributionSourceIds,
+								targetBoard: nextBoard
+							});
+						} catch (error) {
+							console.error(`[factory] intake rebind could not relocate ${binding.integrationId} cards:`, error);
+						}
+					}
+					await audit.emit({
+						context: loose(c),
+						input: {
+							action: "factory.intake.binding_updated",
+							...auditFactoryProjectId ? { factoryProjectId: auditFactoryProjectId } : {},
+							targets: [{
+								type: "intake_source",
+								id: `${binding.integrationId}:${binding.sourceId}`
+							}],
+							metadata: {
+								factoryProjectId: binding.factoryProjectId,
+								board: binding.board,
+								...relocated ? { relocated } : {}
+							}
+						}
+					});
+					return c.json({
+						bindings: await intake.listBindings({ orgId: tenant.orgId }),
+						...relocated ? { relocated } : {}
+					});
+				}
+			}),
+			registerApiRoute("/web/intake/label-routes", {
+				method: "GET",
+				requiresAuth: false,
+				handler: async (c) => {
+					const tenant = await this.#resolveTenant(loose(c));
+					if ("response" in tenant) return tenant.response;
+					const factoryProjectId = c.req.query("factoryProjectId");
+					await intake.ensureReady();
+					return c.json({ routes: await intake.listLabelRoutes({
+						orgId: tenant.orgId,
+						...factoryProjectId ? { factoryProjectId } : {}
+					}) });
+				}
+			}),
+			registerApiRoute("/web/intake/label-routes", {
+				method: "PUT",
+				requiresAuth: false,
+				handler: async (c) => {
+					const tenant = await this.#resolveTenant(loose(c));
+					if ("response" in tenant) return tenant.response;
+					let body;
+					try {
+						body = await c.req.json();
+					} catch {
+						return c.json({ error: "Invalid JSON body" }, 400);
+					}
+					const route = parseIntakeLabelRoute(body);
+					if (!route || !integrationIds.includes(route.integrationId)) return c.json({ error: "invalid_label_route" }, 400);
+					if (projects) {
+						if (!await projects.get({
+							orgId: tenant.orgId,
+							id: route.factoryProjectId
+						})) return c.json({ error: "factory_project_not_found" }, 404);
+					}
+					if (route.board !== null && !boardRegistry?.has(route.board)) return c.json({
+						error: "invalid_board",
+						message: `Board '${route.board}' is not installed.`
+					}, 422);
+					await intake.ensureReady();
+					const scope = {
+						orgId: tenant.orgId,
+						factoryProjectId: route.factoryProjectId,
+						integrationId: route.integrationId
+					};
+					const previous = (await intake.listLabelRoutes(scope)).find((existing) => existing.label === route.label);
+					if (route.board === null) await intake.clearLabelRoute({
+						...scope,
+						label: route.label
+					});
+					else await intake.setLabelRoute({
+						...scope,
+						label: route.label,
+						board: route.board,
+						userId: tenant.userId
+					});
+					let relocated = null;
+					if (workItems && boardRegistry && (previous?.board ?? null) !== route.board) try {
+						relocated = await relocateLabeledCards({
+							workItems,
+							boardRegistry,
+							orgId: tenant.orgId,
+							userId: tenant.userId,
+							factoryProjectId: route.factoryProjectId,
+							integrationId: route.integrationId,
+							label: route.label,
+							routes: await intake.listLabelRoutes(scope),
+							intake,
+							githubRepositories
+						});
+					} catch (error) {
+						console.error(`[factory] intake label route could not relocate ${route.integrationId} cards:`, error);
+					}
+					await audit.emit({
+						context: loose(c),
+						input: {
+							action: "factory.intake.label_route_updated",
+							factoryProjectId: route.factoryProjectId,
+							targets: [{
+								type: "intake_label_route",
+								id: `${route.integrationId}:${route.label}`
+							}],
+							metadata: {
+								board: route.board,
+								...relocated ? { relocated } : {}
+							}
+						}
+					});
+					return c.json({
+						routes: await intake.listLabelRoutes({
+							orgId: tenant.orgId,
+							factoryProjectId: route.factoryProjectId
+						}),
+						...relocated ? { relocated } : {}
+					});
+				}
+			}),
+			registerApiRoute("/web/intake/sources", {
+				method: "GET",
+				requiresAuth: false,
+				handler: async (c) => {
+					const tenant = await this.#resolveTenant(loose(c));
+					if ("response" in tenant) return tenant.response;
+					const { pages, failures } = await settleByIntegration(integrations.map((integration) => ({
+						integrationId: integration.id,
+						read: () => integration.intake.listSources(tenant)
+					})));
+					return c.json({
+						sources: pages.flatMap(({ integrationId, value }) => value.map((source) => ({
+							integrationId,
+							...source
+						}))),
+						failures
+					});
+				}
+			}),
+			registerApiRoute("/web/intake/items", {
+				method: "GET",
+				requiresAuth: false,
+				handler: async (c) => {
+					const tenant = await this.#resolveTenant(loose(c));
+					if ("response" in tenant) return tenant.response;
+					const cursors = decodeCursor(c.req.query("cursor"));
+					if (!cursors) return c.json({ error: "invalid_cursor" }, 400);
+					await intake.ensureReady();
+					const config = await intake.getConfig({
+						orgId: tenant.orgId,
+						integrationIds
+					});
+					const { pages, failures } = await settleByIntegration(integrations.flatMap((integration) => {
+						const selection = config[integration.id];
+						if (!selection?.enabled || !selection.sourceIds?.length) return [];
+						const sourceIds = selection.sourceIds;
+						const cursor = cursors[integration.id];
+						return [{
+							integrationId: integration.id,
+							read: () => integration.intake.listItems({
+								...tenant,
+								sourceIds,
+								...cursor ? { cursor } : {}
+							})
+						}];
+					}));
+					const items = [];
+					const nextCursors = {};
+					for (const { integrationId, value } of pages) {
+						items.push(...value.items.map((item) => {
+							const { source, ...candidate } = item;
+							return {
+								...candidate,
+								integrationId,
+								externalSource: {
+									integrationId,
+									...source
+								}
+							};
+						}));
+						if (value.nextCursor) nextCursors[integrationId] = value.nextCursor;
+					}
+					for (const { integrationId } of failures) {
+						const cursor = cursors[integrationId];
+						if (cursor) nextCursors[integrationId] = cursor;
+					}
+					return c.json({
+						items,
+						nextCursor: encodeCursor(nextCursors),
+						failures
+					});
+				}
+			})
+		];
+	}
+};
+//#endregion
+export { IntakeRoutes, parseIntakeBinding, parseIntakeConfig, parseIntakeLabelRoute };
+
+//# sourceMappingURL=intake.js.map