@mastra/factory 0.2.2-alpha.0 → 0.2.2-alpha.2

package/dist/integrations/linear/routes.js

@@ -1,242 +1,239 @@
-// src/integrations/linear/routes.ts
+import { LinearReauthRequiredError } from "./integration.js";
 import { registerApiRoute } from "@mastra/core/server";
-
-// src/integrations/linear/agent-tools.ts
-import { createTool } from "@mastra/core/tools";
-import { z } from "zod";
-
-// src/integrations/linear/integration.ts
-var LinearReauthRequiredError = class extends Error {
-  constructor() {
-    super("Linear authorization expired. Reconnect Linear to keep syncing intake issues.");
-  }
-};
-
-// src/integrations/linear/routes.ts
-var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+//#region src/integrations/linear/routes.ts
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Erase a route handler's path-parameterized context to a plain `Context`. */
 function loose(c) {
-  return c;
+	return c;
 }
+/**
+* Resolve the org-scoped tenant for a Linear request. The connection is
+* org-owned, so it requires both a signed-in user and an organization — same
+* tenancy rules as the GitHub routes.
+*/
 async function resolveOrgTenant(c, auth) {
-  await auth.ensureUser(c);
-  const tenant = auth.tenant(c);
-  if (!tenant) return { response: c.json({ error: "unauthorized" }, 401) };
-  if (!tenant.orgId) {
-    return {
-      response: c.json(
-        {
-          error: "organization_required",
-          message: "Linear intake requires an organization. Personal accounts cannot connect Linear."
-        },
-        403
-      )
-    };
-  }
-  return { tenant: { orgId: tenant.orgId, userId: tenant.userId } };
+	await auth.ensureUser(c);
+	const tenant = auth.tenant(c);
+	if (!tenant) return { response: c.json({ error: "unauthorized" }, 401) };
+	if (!tenant.orgId) return { response: c.json({
+		error: "organization_required",
+		message: "Linear intake requires an organization. Personal accounts cannot connect Linear."
+	}, 403) };
+	return { tenant: {
+		orgId: tenant.orgId,
+		userId: tenant.userId
+	} };
 }
+/**
+* Validate an opaque Linear pagination cursor from the query string. Cursors
+* are server-issued (`pageInfo.endCursor`), so anything outside a conservative
+* charset/length is rejected rather than forwarded to Linear.
+*/
 function parseAfterCursor(raw) {
-  if (raw === void 0 || raw === "") return void 0;
-  if (raw.length > 512 || !/^[\w+/=.:-]+$/.test(raw)) return null;
-  return raw;
+	if (raw === void 0 || raw === "") return void 0;
+	if (raw.length > 512 || !/^[\w+/=.:-]+$/.test(raw)) return null;
+	return raw;
 }
+/** Map a Linear read failure to the API response for the SPA. */
 function linearFetchError(c, err) {
-  if (err instanceof LinearReauthRequiredError || err.status === 401) {
-    return c.json({ error: "linear_reauth_required", message: new LinearReauthRequiredError().message }, 409);
-  }
-  return c.json({ error: "linear_fetch_failed", message: err instanceof Error ? err.message : String(err) }, 502);
+	if (err instanceof LinearReauthRequiredError || err.status === 401) return c.json({
+		error: "linear_reauth_required",
+		message: new LinearReauthRequiredError().message
+	}, 409);
+	return c.json({
+		error: "linear_fetch_failed",
+		message: err instanceof Error ? err.message : String(err)
+	}, 502);
 }
+/**
+* Build the Linear routes as Mastra `apiRoutes`. When the feature is disabled,
+* returns only the `status` route so the SPA can detect the disabled state.
+*/
 function buildLinearRoutes(options) {
-  const routes = [];
-  const { linear, auth, stateSigner, intake } = options;
-  const enabled = Boolean(linear) && auth.enabled();
-  const diagnostics = () => ({
-    linearAppConfigured: Boolean(linear),
-    factoryAuthEnabled: auth.enabled(),
-    appDbConfigured: true
-  });
-  routes.push(
-    registerApiRoute("/web/linear/status", {
-      method: "GET",
-      requiresAuth: false,
-      handler: async (c) => {
-        if (!enabled || !linear || !stateSigner) {
-          return c.json({
-            enabled: false,
-            connected: false,
-            workspace: null,
-            reason: "missing_config",
-            diagnostics: diagnostics()
-          });
-        }
-        await auth.ensureUser(loose(c));
-        const tenant = auth.tenant(loose(c));
-        if (!tenant) return c.json({ error: "unauthorized", reason: "auth_required" }, 401);
-        if (!tenant.orgId) {
-          return c.json({
-            enabled: true,
-            organizationRequired: true,
-            connected: false,
-            workspace: null,
-            reason: "organization_required",
-            diagnostics: diagnostics()
-          });
-        }
-        const connection = await linear.loadConnection(tenant.orgId);
-        return c.json({
-          enabled: true,
-          connected: Boolean(connection),
-          workspace: connection ? { name: connection.workspaceName, urlKey: connection.workspaceUrlKey } : null,
-          reason: connection ? "ready" : "not_connected",
-          diagnostics: diagnostics()
-        });
-      }
-    })
-  );
-  if (!enabled || !linear || !stateSigner || !intake) {
-    return routes;
-  }
-  const redirectUri = options.redirectUri ?? `${(options.baseUrl ?? "").replace(/\/$/, "")}/auth/linear/callback`;
-  routes.push(
-    registerApiRoute("/auth/linear/connect", {
-      method: "GET",
-      requiresAuth: false,
-      handler: async (c) => {
-        const resolved = await resolveOrgTenant(loose(c), auth);
-        if ("response" in resolved) return resolved.response;
-        const state = stateSigner.sign(resolved.tenant.orgId, resolved.tenant.userId);
-        return c.redirect(linear.buildAuthorizeUrl(state, redirectUri));
-      }
-    })
-  );
-  routes.push(
-    registerApiRoute("/auth/linear/callback", {
-      method: "GET",
-      requiresAuth: false,
-      handler: async (c) => {
-        const resolved = await resolveOrgTenant(loose(c), auth);
-        if ("response" in resolved) return resolved.response;
-        const { orgId, userId } = resolved.tenant;
-        const stateTenant = stateSigner.verify(c.req.query("state"));
-        if (!stateTenant || stateTenant.userId !== userId || stateTenant.orgId !== orgId) {
-          console.warn("[Linear] OAuth callback rejected: state/tenant mismatch.");
-          return c.redirect("/?linear=error");
-        }
-        const code = c.req.query("code");
-        if (!code) {
-          return c.redirect("/?linear=error");
-        }
-        try {
-          const tokens = await linear.exchangeOAuthCode(code, redirectUri);
-          const workspace = await linear.fetchWorkspace(tokens.accessToken);
-          await linear.upsertConnection({
-            orgId,
-            userId,
-            accessToken: tokens.accessToken,
-            refreshToken: tokens.refreshToken,
-            expiresAt: tokens.expiresAt,
-            scope: tokens.scope,
-            workspaceName: workspace.name,
-            workspaceUrlKey: workspace.urlKey
-          });
-        } catch (error) {
-          console.warn(`[Linear] OAuth callback failed to persist connection for org ${orgId}.`, error);
-          return c.redirect("/?linear=error");
-        }
-        return c.redirect("/?linear=connected");
-      }
-    })
-  );
-  routes.push(
-    registerApiRoute("/web/linear/projects", {
-      method: "GET",
-      requiresAuth: false,
-      handler: async (c) => {
-        const resolved = await resolveOrgTenant(loose(c), auth);
-        if ("response" in resolved) return resolved.response;
-        const connection = await linear.loadConnection(resolved.tenant.orgId);
-        if (!connection) {
-          return c.json({ error: "linear_not_connected", message: "Connect Linear to list Linear projects." }, 409);
-        }
-        try {
-          const accessToken = await linear.getFreshAccessToken(connection);
-          const projects = await linear.listProjects(accessToken);
-          return c.json({ projects });
-        } catch (err) {
-          return linearFetchError(loose(c), err);
-        }
-      }
-    })
-  );
-  routes.push(
-    registerApiRoute("/web/linear/issues", {
-      method: "GET",
-      requiresAuth: false,
-      handler: async (c) => {
-        const resolved = await resolveOrgTenant(loose(c), auth);
-        if ("response" in resolved) return resolved.response;
-        const after = parseAfterCursor(c.req.query("after"));
-        if (after === null) return c.json({ error: "invalid_cursor" }, 400);
-        const factoryProjectId = c.req.query("factoryProjectId");
-        if (factoryProjectId && !UUID_RE.test(factoryProjectId)) {
-          return c.json({ error: "invalid_factory_project_id" }, 400);
-        }
-        const connection = await linear.loadConnection(resolved.tenant.orgId);
-        if (!connection) {
-          return c.json({ error: "linear_not_connected", message: "Connect Linear to see intake issues." }, 409);
-        }
-        await intake.ensureReady();
-        const config = await intake.getConfig({
-          orgId: resolved.tenant.orgId,
-          userId: resolved.tenant.userId,
-          integrationIds: ["linear"]
-        });
-        const selection = config.linear;
-        if (!selection.enabled) {
-          return c.json({ error: "linear_intake_disabled", message: "Linear intake is turned off in Settings." }, 404);
-        }
-        const projectIds = selection.sourceIds ?? [];
-        if (projectIds.length === 0) {
-          return c.json({ issues: [], nextCursor: null });
-        }
-        try {
-          const accessToken = await linear.getFreshAccessToken(connection);
-          const { issues, nextCursor } = await linear.intake.listIssues({
-            connection: { type: "oauth", accessToken },
-            sourceIds: projectIds,
-            cursor: after
-          });
-          const issuePayload = issues.map((issue) => ({
-            id: issue.id,
-            identifier: issue.identifier,
-            title: issue.title,
-            url: issue.url,
-            state: issue.state ?? "",
-            stateType: issue.stateType ?? "",
-            priorityLabel: issue.priority ?? "",
-            assignee: issue.assignee,
-            team: issue.source,
-            labels: issue.labels,
-            createdAt: issue.createdAt,
-            updatedAt: issue.updatedAt
-          }));
-          if (factoryProjectId && options.ingestFactoryIssues) {
-            await options.ingestFactoryIssues({
-              orgId: resolved.tenant.orgId,
-              userId: resolved.tenant.userId,
-              factoryProjectId,
-              issues: issuePayload
-            });
-          }
-          return c.json({ issues: issuePayload, nextCursor });
-        } catch (err) {
-          return linearFetchError(loose(c), err);
-        }
-      }
-    })
-  );
-  return routes;
+	const routes = [];
+	const { linear, auth, stateSigner, intake } = options;
+	const enabled = Boolean(linear) && auth.enabled();
+	const diagnostics = () => ({
+		linearAppConfigured: Boolean(linear),
+		factoryAuthEnabled: auth.enabled(),
+		appDbConfigured: true
+	});
+	routes.push(registerApiRoute("/web/linear/status", {
+		method: "GET",
+		requiresAuth: false,
+		handler: async (c) => {
+			if (!enabled || !linear || !stateSigner) return c.json({
+				enabled: false,
+				connected: false,
+				workspace: null,
+				reason: "missing_config",
+				diagnostics: diagnostics()
+			});
+			await auth.ensureUser(loose(c));
+			const tenant = auth.tenant(loose(c));
+			if (!tenant) return c.json({
+				error: "unauthorized",
+				reason: "auth_required"
+			}, 401);
+			if (!tenant.orgId) return c.json({
+				enabled: true,
+				organizationRequired: true,
+				connected: false,
+				workspace: null,
+				reason: "organization_required",
+				diagnostics: diagnostics()
+			});
+			const connection = await linear.loadConnection(tenant.orgId);
+			return c.json({
+				enabled: true,
+				connected: Boolean(connection),
+				workspace: connection ? {
+					name: connection.workspaceName,
+					urlKey: connection.workspaceUrlKey
+				} : null,
+				reason: connection ? "ready" : "not_connected",
+				diagnostics: diagnostics()
+			});
+		}
+	}));
+	if (!enabled || !linear || !stateSigner || !intake) return routes;
+	const redirectUri = options.redirectUri ?? `${(options.baseUrl ?? "").replace(/\/$/, "")}/auth/linear/callback`;
+	routes.push(registerApiRoute("/auth/linear/connect", {
+		method: "GET",
+		requiresAuth: false,
+		handler: async (c) => {
+			const resolved = await resolveOrgTenant(loose(c), auth);
+			if ("response" in resolved) return resolved.response;
+			const state = stateSigner.sign(resolved.tenant.orgId, resolved.tenant.userId);
+			return c.redirect(linear.buildAuthorizeUrl(state, redirectUri));
+		}
+	}));
+	routes.push(registerApiRoute("/auth/linear/callback", {
+		method: "GET",
+		requiresAuth: false,
+		handler: async (c) => {
+			const resolved = await resolveOrgTenant(loose(c), auth);
+			if ("response" in resolved) return resolved.response;
+			const { orgId, userId } = resolved.tenant;
+			const stateTenant = stateSigner.verify(c.req.query("state"));
+			if (!stateTenant || stateTenant.userId !== userId || stateTenant.orgId !== orgId) {
+				console.warn("[Linear] OAuth callback rejected: state/tenant mismatch.");
+				return c.redirect("/?linear=error");
+			}
+			const code = c.req.query("code");
+			if (!code) return c.redirect("/?linear=error");
+			try {
+				const tokens = await linear.exchangeOAuthCode(code, redirectUri);
+				const workspace = await linear.fetchWorkspace(tokens.accessToken);
+				await linear.upsertConnection({
+					orgId,
+					userId,
+					accessToken: tokens.accessToken,
+					refreshToken: tokens.refreshToken,
+					expiresAt: tokens.expiresAt,
+					scope: tokens.scope,
+					workspaceName: workspace.name,
+					workspaceUrlKey: workspace.urlKey
+				});
+			} catch (error) {
+				console.warn(`[Linear] OAuth callback failed to persist connection for org ${orgId}.`, error);
+				return c.redirect("/?linear=error");
+			}
+			return c.redirect("/?linear=connected");
+		}
+	}));
+	routes.push(registerApiRoute("/web/linear/projects", {
+		method: "GET",
+		requiresAuth: false,
+		handler: async (c) => {
+			const resolved = await resolveOrgTenant(loose(c), auth);
+			if ("response" in resolved) return resolved.response;
+			const connection = await linear.loadConnection(resolved.tenant.orgId);
+			if (!connection) return c.json({
+				error: "linear_not_connected",
+				message: "Connect Linear to list Linear projects."
+			}, 409);
+			try {
+				const accessToken = await linear.getFreshAccessToken(connection);
+				const projects = await linear.listProjects(accessToken);
+				return c.json({ projects });
+			} catch (err) {
+				return linearFetchError(loose(c), err);
+			}
+		}
+	}));
+	routes.push(registerApiRoute("/web/linear/issues", {
+		method: "GET",
+		requiresAuth: false,
+		handler: async (c) => {
+			const resolved = await resolveOrgTenant(loose(c), auth);
+			if ("response" in resolved) return resolved.response;
+			const after = parseAfterCursor(c.req.query("after"));
+			if (after === null) return c.json({ error: "invalid_cursor" }, 400);
+			const factoryProjectId = c.req.query("factoryProjectId");
+			if (factoryProjectId && !UUID_RE.test(factoryProjectId)) return c.json({ error: "invalid_factory_project_id" }, 400);
+			const connection = await linear.loadConnection(resolved.tenant.orgId);
+			if (!connection) return c.json({
+				error: "linear_not_connected",
+				message: "Connect Linear to see intake issues."
+			}, 409);
+			await intake.ensureReady();
+			const selection = (await intake.getConfig({
+				orgId: resolved.tenant.orgId,
+				userId: resolved.tenant.userId,
+				integrationIds: ["linear"]
+			})).linear;
+			if (!selection.enabled) return c.json({
+				error: "linear_intake_disabled",
+				message: "Linear intake is turned off in Settings."
+			}, 404);
+			const projectIds = selection.sourceIds ?? [];
+			if (projectIds.length === 0) return c.json({
+				issues: [],
+				nextCursor: null
+			});
+			try {
+				const accessToken = await linear.getFreshAccessToken(connection);
+				const { issues, nextCursor } = await linear.intake.listIssues({
+					connection: {
+						type: "oauth",
+						accessToken
+					},
+					sourceIds: projectIds,
+					cursor: after
+				});
+				const issuePayload = issues.map((issue) => ({
+					id: issue.id,
+					identifier: issue.identifier,
+					title: issue.title,
+					url: issue.url,
+					state: issue.state ?? "",
+					stateType: issue.stateType ?? "",
+					priorityLabel: issue.priority ?? "",
+					assignee: issue.assignee,
+					team: issue.source,
+					labels: issue.labels,
+					createdAt: issue.createdAt,
+					updatedAt: issue.updatedAt
+				}));
+				if (factoryProjectId && options.ingestFactoryIssues) await options.ingestFactoryIssues({
+					orgId: resolved.tenant.orgId,
+					userId: resolved.tenant.userId,
+					factoryProjectId,
+					issues: issuePayload
+				});
+				return c.json({
+					issues: issuePayload,
+					nextCursor
+				});
+			} catch (err) {
+				return linearFetchError(loose(c), err);
+			}
+		}
+	}));
+	return routes;
 }
-export {
-  buildLinearRoutes
-};
+//#endregion
+export { buildLinearRoutes };
+
 //# sourceMappingURL=routes.js.map