@mastra/factory 0.0.0 → 0.1.0-alpha.3

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

@@ -0,0 +1,891 @@
+// src/integrations/platform/linear/integration.ts
+import { registerApiRoute as registerApiRoute2 } from "@mastra/core/server";
+
+// src/integrations/linear/agent-tools.ts
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+
+// src/integrations/linear/routes.ts
+import { registerApiRoute } from "@mastra/core/server";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function loose(c) {
+  return c;
+}
+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 } };
+}
+function parseAfterCursor(raw) {
+  if (raw === void 0 || raw === "") return void 0;
+  if (raw.length > 512 || !/^[\w+/=.:-]+$/.test(raw)) return null;
+  return raw;
+}
+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);
+}
+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.hooks?.ingestLinearIssues) {
+            await options.hooks.ingestLinearIssues({
+              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;
+}
+
+// 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/agent-tools.ts
+function createLinearGetIssueTool(linear, orgId) {
+  return createTool({
+    id: "linear_get_issue",
+    description: "Fetch a Linear issue's full details \u2014 title, description, state, assignee, labels, priority, and discussion comments. Use this whenever you're working on a Linear issue (e.g. ENG-123) to get its complete context.",
+    inputSchema: z.object({
+      issue: z.string().min(1).describe('The Linear issue identifier (e.g. "ENG-123") or issue UUID.')
+    }),
+    execute: async ({ issue }) => {
+      const connection = await linear.loadConnection(orgId);
+      if (!connection) {
+        return { error: "Linear is not connected for this repository. Connect Linear in Settings to fetch issues." };
+      }
+      try {
+        const accessToken = await linear.getFreshAccessToken(connection);
+        const detail = await linear.intake.getIssue({
+          connection: { type: "oauth", accessToken },
+          issueId: issue.trim()
+        });
+        if (!detail) {
+          return { error: `Linear issue "${issue}" was not found in this workspace.` };
+        }
+        return detail;
+      } catch (err) {
+        if (err instanceof LinearReauthRequiredError) {
+          return { error: err.message };
+        }
+        return { error: `Failed to fetch Linear issue: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    }
+  });
+}
+function createLinearCommentTool(linear, orgId) {
+  return createTool({
+    id: "linear_create_comment",
+    description: "Post a comment on a Linear issue (e.g. to report investigation findings, link a PR, or ask a clarifying question). The comment is posted as the connected Linear integration, so make clear it comes from the agent.",
+    inputSchema: z.object({
+      issue: z.string().min(1).describe('The Linear issue identifier (e.g. "ENG-123") or issue UUID.'),
+      body: z.string().min(1).describe("The comment body, as Linear-flavored markdown.")
+    }),
+    execute: async ({ issue, body }) => {
+      const connection = await linear.loadConnection(orgId);
+      if (!connection) {
+        return { error: "Linear is not connected for this repository. Connect Linear in Settings to post comments." };
+      }
+      if (!linear.canPostComments(connection)) {
+        return {
+          error: "The Linear connection does not have comment permissions. Reconnect Linear in Settings to grant them."
+        };
+      }
+      try {
+        const accessToken = await linear.getFreshAccessToken(connection);
+        const comment = await linear.intake.createComment({
+          connection: { type: "oauth", accessToken },
+          issueId: issue.trim(),
+          body
+        });
+        if (!comment) {
+          return { error: `Linear issue "${issue}" was not found in this workspace.` };
+        }
+        return { posted: true, url: comment.url };
+      } catch (err) {
+        if (err instanceof LinearReauthRequiredError) {
+          return { error: err.message };
+        }
+        return { error: `Failed to post Linear comment: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    }
+  });
+}
+async function buildLinearAgentTools({
+  requestContext,
+  linear
+}) {
+  if (!linear.authEnabled) return {};
+  const ctx = requestContext.get("controller");
+  const resourceId = ctx?.resourceId;
+  if (!resourceId) return {};
+  const orgId = await linear.resolveOrgId(resourceId);
+  if (!orgId) return {};
+  const check = await linear.checkConnection(orgId);
+  if (!check.connected) return {};
+  return {
+    linear_get_issue: createLinearGetIssueTool(linear, orgId),
+    // Only offered when the granted OAuth scope allows posting comments —
+    // connections made before `comments:create` was requested are read-only
+    // until the org reconnects Linear.
+    ...check.canComment ? { linear_create_comment: createLinearCommentTool(linear, orgId) } : {}
+  };
+}
+
+// src/integrations/platform/api-client.ts
+function platformApiClientConfigFromEnv() {
+  const sharedApiUrl = process.env.MASTRA_SHARED_API_URL?.trim() || "https://platform.mastra.ai/v1";
+  const accessToken = process.env.MASTRA_PLATFORM_SECRET_KEY?.trim();
+  if (!accessToken) {
+    throw new Error("Platform integration: missing required environment variable MASTRA_PLATFORM_SECRET_KEY.");
+  }
+  return { baseUrl: normalizeSharedApiUrl(sharedApiUrl), accessToken };
+}
+function normalizeSharedApiUrl(sharedApiUrl) {
+  return sharedApiUrl.replace(/\/+$/, "").replace(/\/v1$/, "");
+}
+var PlatformApiError = class extends Error {
+  status;
+  retryAfterSeconds;
+  constructor(message, status, retryAfterSeconds = null) {
+    super(message);
+    this.name = "PlatformApiError";
+    this.status = status;
+    this.retryAfterSeconds = retryAfterSeconds;
+  }
+};
+var PlatformApiClient = class {
+  #baseUrl;
+  #accessToken;
+  #fetch;
+  constructor(config) {
+    const missing = ["baseUrl", "accessToken"].filter((field) => !config[field]);
+    if (missing.length > 0) {
+      throw new Error(`Platform integration: missing required config field(s): ${missing.join(", ")}.`);
+    }
+    this.#baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.#accessToken = config.accessToken;
+    this.#fetch = config.fetchImpl ?? globalThis.fetch;
+  }
+  async request(method, path, body, options) {
+    const response = await this.#send(method, path, body, options);
+    if (!response.ok) {
+      const message = redact(await extractError(response), this.#accessToken);
+      const retryAfterSeconds = parseRetryAfter(response.headers.get("retry-after"));
+      logPlatformError("Platform API request failed", {
+        method,
+        path,
+        status: response.status,
+        retryAfterSeconds,
+        message
+      });
+      throw new PlatformApiError(message, response.status, retryAfterSeconds);
+    }
+    if (response.status === 204) return void 0;
+    return await response.json();
+  }
+  async requestRedirect(method, path, options) {
+    const response = await this.#send(method, path, void 0, options, "manual");
+    if (response.status >= 300 && response.status < 400) {
+      const location = response.headers.get("location");
+      if (location) return location;
+    }
+    if (!response.ok) {
+      const message = redact(await extractError(response), this.#accessToken);
+      const retryAfterSeconds = parseRetryAfter(response.headers.get("retry-after"));
+      logPlatformError("Platform API redirect request failed", {
+        method,
+        path,
+        status: response.status,
+        retryAfterSeconds,
+        message
+      });
+      throw new PlatformApiError(message, response.status, retryAfterSeconds);
+    }
+    logPlatformError("Platform API request did not return a redirect", { method, path, status: response.status });
+    throw new PlatformApiError("Platform API request did not return a redirect.", response.status);
+  }
+  async #send(method, path, body, options, redirect) {
+    const headers = {
+      accept: "application/json",
+      authorization: `Bearer ${this.#accessToken}`
+    };
+    const timeoutSignal = AbortSignal.timeout(15e3);
+    const init = {
+      method,
+      headers,
+      redirect,
+      signal: options?.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal
+    };
+    if (body !== void 0) {
+      headers["content-type"] = "application/json";
+      init.body = JSON.stringify(body);
+    }
+    try {
+      return await this.#fetch(`${this.#baseUrl}${path}`, init);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes(this.#accessToken)) {
+        const redacted = new Error(redact(error.message, this.#accessToken));
+        redacted.name = error.name;
+        logPlatformError("Platform API transport error", {
+          method,
+          path,
+          name: redacted.name,
+          message: redacted.message
+        });
+        throw redacted;
+      }
+      logPlatformError("Platform API transport error", {
+        method,
+        path,
+        name: error instanceof Error ? error.name : void 0,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+};
+async function extractError(response) {
+  try {
+    const data = await response.clone().json();
+    for (const field of ["detail", "error", "title"]) {
+      if (typeof data[field] === "string" && data[field]) return data[field];
+    }
+  } catch {
+  }
+  return `Platform API request failed (${response.status})`;
+}
+function redact(message, accessToken) {
+  return message.split(accessToken).join("[REDACTED]");
+}
+function logPlatformInfo(message, fields) {
+  writePlatformLog("info", message, fields);
+}
+function logPlatformError(message, fields) {
+  writePlatformLog("error", message, fields);
+}
+function writePlatformLog(level, message, fields) {
+  const metadata = fields ? ` ${JSON.stringify(stripUndefined(fields))}` : "";
+  process.stderr.write(`[MastraCode Web] ${level.toUpperCase()} ${message}${metadata}
+`);
+}
+function stripUndefined(fields) {
+  return Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== void 0));
+}
+function parseRetryAfter(value) {
+  if (!value) return null;
+  const seconds = Number.parseInt(value, 10);
+  return Number.isSafeInteger(seconds) && seconds >= 0 ? seconds : null;
+}
+
+// src/integrations/platform/linear/integration.ts
+var API_PREFIX = "/v1/server/linear";
+var PAGE_SIZE = 30;
+var MAX_REFERENCE_PAGES = 20;
+var MAX_COMMENT_PAGES = 20;
+var PLATFORM_MANAGED_CONNECTION_TOKEN = "platform-managed";
+function loose2(c) {
+  return c;
+}
+function routeBaseUrl(ctx, requestUrl) {
+  return (ctx.baseUrl || new URL(requestUrl).origin).replace(/\/+$/, "");
+}
+var PlatformLinearIntegration = class {
+  id = "linear";
+  #client;
+  #endpointHost;
+  #projects;
+  #auth;
+  intake = {
+    listSources: async () => {
+      const sources = await this.#listProjectSources();
+      return sources.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
+        }
+      }));
+    },
+    listItems: async ({ sourceIds, cursor }) => {
+      const result = await this.#listIssues(sourceIds, cursor);
+      return {
+        items: result.issues.map(({ issue, source }) => ({
+          source: { type: "issue", externalId: issue.id, url: issue.url },
+          sourceId: encodeSourceId(source.workspace.linearWorkspaceId, source.project.id),
+          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: source.workspace.linearWorkspaceId,
+            workspaceName: source.workspace.linearWorkspaceName,
+            projectId: source.project.id,
+            projectName: source.project.name,
+            team: issue.team.key,
+            priority: issue.priorityLabel
+          }
+        })),
+        nextCursor: result.nextCursor
+      };
+    },
+    listIssues: async ({ connection, sourceIds, labels, cursor }) => {
+      requireLinearConnection(connection);
+      const result = await this.#listIssues(sourceIds, cursor, labels);
+      return {
+        issues: result.issues.map(({ issue }) => parseIssue(issue)),
+        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);
+    },
+    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;
+      }
+    }
+  };
+  constructor() {
+    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 {
+      const project = await this.projects.getById({ id: resourceId });
+      return project?.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;
+  }
+  canPostComments(connection) {
+    const scopes = (connection.scope ?? "").split(/[\s,]+/).filter(Boolean);
+    return scopes.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()
+    };
+  }
+  routes(ctx) {
+    return [
+      this.#connectRoute(ctx),
+      ...buildLinearRoutes({
+        auth: ctx.auth,
+        linear: this,
+        stateSigner: ctx.stateSigner,
+        baseUrl: ctx.baseUrl,
+        intake: ctx.storage.intake
+      }).filter((route) => !route.path.startsWith("/auth/linear/"))
+    ];
+  }
+  #connectRoute(ctx) {
+    return registerApiRoute2("/auth/linear/connect", {
+      method: "GET",
+      requiresAuth: false,
+      handler: async (c) => {
+        await ctx.auth.ensureUser(loose2(c));
+        const tenant = ctx.auth.tenant(loose2(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 #listProjectSources() {
+    const workspaces = await this.#listWorkspaces();
+    const projectGroups = await Promise.all(
+      workspaces.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;
+          after = result.pageInfo.endCursor;
+        }
+        return projects.map((project) => ({ workspace, project }));
+      })
+    );
+    return projectGroups.flat();
+  }
+  async #listWorkspaces() {
+    const result = await this.#client.request("GET", `${API_PREFIX}/workspaces`);
+    return result.workspaces.filter((workspace) => workspace.connected);
+  }
+  async #listIssues(sourceIds, cursor, labels) {
+    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 normalizedLabels = normalizeLabels(labels);
+    const nextState = {};
+    let hasNextPage = false;
+    const pages = await Promise.all(
+      selected.map(async (source) => {
+        const sourceId = encodeSourceId(source.workspace.linearWorkspaceId, source.project.id);
+        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 next = result.pageInfo.hasNextPage ? result.pageInfo.endCursor : null;
+        nextState[sourceId] = next;
+        hasNextPage ||= next !== null;
+        return result.issues.filter(
+          (issue) => normalizedLabels.length === 0 || issue.labels.some((label) => normalizedLabels.includes(label.name))
+        ).map((issue) => ({ issue, source }));
+      })
+    );
+    return {
+      issues: pages.flat(),
+      nextCursor: hasNextPage ? encodeCursor(nextState, sourceIds) : null
+    };
+  }
+  async #findIssue(sourceId, issueId) {
+    const workspaceIds = await this.#candidateWorkspaceIds(sourceId);
+    for (const workspaceId of workspaceIds) {
+      try {
+        const issue = await this.#client.request(
+          "GET",
+          `${API_PREFIX}/workspaces/${encodeURIComponent(workspaceId)}/issues/${encodeURIComponent(issueId)}?include=comments`
+        );
+        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 #candidateWorkspaceIds(sourceId) {
+    if (sourceId) return [decodeSourceId(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);
+      pageInfo = result.pageInfo;
+      page += 1;
+    }
+    return comments;
+  }
+};
+function parseIssue(issue) {
+  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,
+    labels: issue.labels.map((label) => label.name),
+    commentCount: null,
+    createdAt: issue.createdAt,
+    updatedAt: issue.updatedAt
+  };
+}
+function parseIssueDetail(issue, comments) {
+  return {
+    ...parseIssue(issue),
+    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
+    }))
+  };
+}
+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("linear-project:".length), "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.");
+  }
+}
+function normalizeLabels(labels) {
+  return [...new Set((labels ?? []).map((label) => label.trim()).filter(Boolean))];
+}
+function decodeCursor(cursor, sourceIds) {
+  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;
+  } catch {
+    throw new Error("Linear cursor is invalid.");
+  }
+}
+function encodeCursor(state, sourceIds) {
+  if (sourceIds.length === 1) return state[sourceIds[0]];
+  return JSON.stringify(state);
+}
+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;
+}
+export {
+  PlatformLinearIntegration
+};
+//# sourceMappingURL=integration.js.map